pax_global_header00006660000000000000000000000064145634665720014534gustar00rootroot0000000000000052 comment=4c65a7d49495c6a70567c9ec8f7c13a5ebe196ba test-unit-3.6.2/000077500000000000000000000000001456346657200135005ustar00rootroot00000000000000test-unit-3.6.2/.github/000077500000000000000000000000001456346657200150405ustar00rootroot00000000000000test-unit-3.6.2/.github/dependabot.yml000066400000000000000000000001651456346657200176720ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "daily" test-unit-3.6.2/.github/workflows/000077500000000000000000000000001456346657200170755ustar00rootroot00000000000000test-unit-3.6.2/.github/workflows/release.yml000066400000000000000000000016161456346657200212440ustar00rootroot00000000000000name: Release on: push: tags: - "*" jobs: github: name: GitHub runs-on: ubuntu-latest timeout-minutes: 10 steps: - uses: actions/checkout@v4 - name: Extract release note run: | ruby \ -e 'print("## test-unit "); \ puts(ARGF.read.split(/^## /)[1]. \ gsub(/ {.+?}/, ""). \ gsub(/\[(.+?)\]\[.+?\]/) {$1})' \ doc/text/news.md > release-note.md - name: Upload to release run: | title=$(head -n1 release-note.md | sed -e 's/^## //') tail -n +2 release-note.md > release-note-without-version.md gh release create ${GITHUB_REF_NAME} \ --discussion-category Announcements \ --notes-file release-note-without-version.md \ --title "${title}" env: GH_TOKEN: ${{ github.token }} test-unit-3.6.2/.github/workflows/test.yml000066400000000000000000000104361456346657200206030ustar00rootroot00000000000000name: Test on: - push - pull_request jobs: run: strategy: fail-fast: false matrix: include: - name: "2.1" ruby-version: "2.1" runs-on: "ubuntu-latest" # Disabled because ruby/setup-ruby doesn't work. # - name: "2.2" # ruby-version: "2.2" # runs-on: "ubuntu-latest" - name: "2.3" ruby-version: "2.3" runs-on: "ubuntu-latest" - name: "2.4" ruby-version: "2.4" runs-on: "ubuntu-latest" - name: "2.4 + frozen string literal" ruby-version: "2.4" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "2.5" ruby-version: "2.5" runs-on: "ubuntu-latest" # Disabled because RubyGems doesn't support frozen string literal. # - name: "2.5 + frozen string literal" # ruby-version: "2.5" # runs-on: "ubuntu-latest" # rubyopt: "--enable-frozen-string-literal" - name: "2.6" ruby-version: "2.6" runs-on: "ubuntu-latest" - name: "2.6 + frozen string literal" ruby-version: "2.6" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "2.7" ruby-version: "2.7" runs-on: "ubuntu-latest" - name: "2.7 + frozen string literal" ruby-version: "2.7" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "3.0" ruby-version: "3.0" runs-on: "ubuntu-latest" - name: "3.0 + frozen string literal" ruby-version: "3.0" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "3.1" ruby-version: "3.1" runs-on: "ubuntu-latest" - name: "3.1 + frozen string literal" ruby-version: "3.1" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "3.1 on macOS" ruby-version: "3.1" runs-on: "macos-latest" - name: "3.1 on Windows" ruby-version: "3.1" runs-on: "windows-latest" - name: "3.2" ruby-version: "3.2" runs-on: "ubuntu-latest" - name: "3.2 + frozen string literal" ruby-version: "3.2" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "3.2 on macOS" ruby-version: "3.2" runs-on: "macos-latest" - name: "3.2 on Windows" ruby-version: "3.2" runs-on: "windows-latest" - name: "3.3" ruby-version: "3.3" runs-on: "ubuntu-latest" - name: "3.3 + frozen string literal" ruby-version: "3.3" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "3.3 on macOS" ruby-version: "3.3" runs-on: "macos-latest" - name: "3.3 on Windows" ruby-version: "3.3" runs-on: "windows-latest" - name: "head" ruby-version: "head" runs-on: "ubuntu-latest" - name: "head + frozen string literal" ruby-version: "head" runs-on: "ubuntu-latest" rubyopt: "--enable-frozen-string-literal" - name: "JRuby" ruby-version: "jruby" runs-on: "ubuntu-latest" - name: "JRuby - head" ruby-version: "jruby-head" runs-on: "ubuntu-latest" - name: "TruffleRuby" ruby-version: "truffleruby" runs-on: "ubuntu-latest" - name: "TruffleRuby - head" ruby-version: "truffleruby-head" runs-on: "ubuntu-latest" name: ${{ matrix.name }} runs-on: ${{ matrix.runs-on }} steps: - uses: actions/checkout@v4 - uses: ruby/setup-ruby@v1 with: ruby-version: ${{ matrix.ruby-version }} - name: Install dependencies run: | bundle install - name: Test run: | bundle exec rake env: RUBYOPT: ${{ matrix.rubyopt }} test-unit-3.6.2/.gitignore000066400000000000000000000001341456346657200154660ustar00rootroot00000000000000/doc/reference/ /doc/html/test-unit/ /doc/po/*.pot /doc/po/*/ /pkg/ /.yardoc/ /Gemfile.lock test-unit-3.6.2/.yardopts000066400000000000000000000002441456346657200153460ustar00rootroot00000000000000--title test-unit --readme README.md --markup markdown --markup-provider kramdown --files doc/text/**/*.* --output-dir doc/reference/en --charset utf-8 --use-cache test-unit-3.6.2/BSDL000066400000000000000000000025711456346657200141540ustar00rootroot00000000000000Copyright (C) 2003-2007 Nathaniel Talbott. All rights reserved. Copyright (C) 2008 Ryan Davis. All rights reserved. Copyright (C) 2008-2020 Sutou Kouhei. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. test-unit-3.6.2/COPYING000066400000000000000000000050411456346657200145330ustar00rootroot00000000000000test-unit is copyrighted free software by Kouhei Sutou , Ryan Davis and Nathaniel Talbott . You can redistribute it and/or modify it under either the terms of the 2-clause BSDL (see the file BSDL), or the conditions below: 1. You may make and give away verbatim copies of the source form of the software without restriction, provided that you duplicate all of the original copyright notices and associated disclaimers. 2. You may modify your copy of the software in any way, provided that you do at least ONE of the following: a. place your modifications in the Public Domain or otherwise make them Freely Available, such as by posting said modifications to Usenet or an equivalent medium, or by allowing the author to include your modifications in the software. b. use the modified software only within your corporation or organization. c. give non-standard binaries non-standard names, with instructions on where to get the original software distribution. d. make other distribution arrangements with the author. 3. You may distribute the software in object code or binary form, provided that you do at least ONE of the following: a. distribute the binaries and library files of the software, together with instructions (in the manual page or equivalent) on where to get the original distribution. b. accompany the distribution with the machine-readable source of the software. c. give non-standard binaries non-standard names, with instructions on where to get the original software distribution. d. make other distribution arrangements with the author. 4. You may modify and include the part of the software into any other software (possibly commercial). But some files in the distribution are not written by the author, so that they are not under these terms. For the list of those files and their copying conditions, see the file LEGAL. 5. The scripts and library files supplied as input to or produced as output from the software do not automatically fall under the copyright of the software, but belong to whomever generated them, and may be sold commercially, and may be aggregated with this software. 6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. Exceptions ---------- * lib/test/unit/diff.rb: This license and PSF license test-unit-3.6.2/Gemfile000066400000000000000000000003211456346657200147670ustar00rootroot00000000000000# -*- mode: ruby; coding: utf-8 -*- source "https://rubygems.org" gemspec group :test do gem "bigdecimal", platforms: [:mri] gem "csv" if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.4.0") end test-unit-3.6.2/PSFL000066400000000000000000000324461456346657200142000ustar00rootroot00000000000000This is the official license for the Python 2.5 release: A. HISTORY OF THE SOFTWARE ========================== Python was created in the early 1990s by Guido van Rossum at Stichting Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands as a successor of a language called ABC. Guido remains Python's principal author, although it includes many contributions from others. In 1995, Guido continued his work on Python at the Corporation for National Research Initiatives (CNRI, see http://www.cnri.reston.va.us) in Reston, Virginia where he released several versions of the software. In May 2000, Guido and the Python core development team moved to BeOpen.com to form the BeOpen PythonLabs team. In October of the same year, the PythonLabs team moved to Digital Creations (now Zope Corporation, see http://www.zope.com). In 2001, the Python Software Foundation (PSF, see http://www.python.org/psf/) was formed, a non-profit organization created specifically to own Python-related Intellectual Property. Zope Corporation is a sponsoring member of the PSF. All Python releases are Open Source (see http://www.opensource.org for the Open Source Definition). Historically, most, but not all, Python releases have also been GPL-compatible; the table below summarizes the various releases. Release Derived Year Owner GPL- from compatible? (1) 0.9.0 thru 1.2 1991-1995 CWI yes 1.3 thru 1.5.2 1.2 1995-1999 CNRI yes 1.6 1.5.2 2000 CNRI no 2.0 1.6 2000 BeOpen.com no 1.6.1 1.6 2001 CNRI yes (2) 2.1 2.0+1.6.1 2001 PSF no 2.0.1 2.0+1.6.1 2001 PSF yes 2.1.1 2.1+2.0.1 2001 PSF yes 2.2 2.1.1 2001 PSF yes 2.1.2 2.1.1 2002 PSF yes 2.1.3 2.1.2 2002 PSF yes 2.2.1 2.2 2002 PSF yes 2.2.2 2.2.1 2002 PSF yes 2.2.3 2.2.2 2003 PSF yes 2.3 2.2.2 2002-2003 PSF yes 2.3.1 2.3 2002-2003 PSF yes 2.3.2 2.3.1 2002-2003 PSF yes 2.3.3 2.3.2 2002-2003 PSF yes 2.3.4 2.3.3 2004 PSF yes 2.3.5 2.3.4 2005 PSF yes 2.4 2.3 2004 PSF yes 2.4.1 2.4 2005 PSF yes 2.4.2 2.4.1 2005 PSF yes 2.4.3 2.4.2 2006 PSF yes 2.5 2.4 2006 PSF yes Footnotes: (1) GPL-compatible doesn't mean that we're distributing Python under the GPL. All Python licenses, unlike the GPL, let you distribute a modified version without making your changes open source. The GPL-compatible licenses make it possible to combine Python with other software that is released under the GPL; the others don't. (2) According to Richard Stallman, 1.6.1 is not GPL-compatible, because its license has a choice of law clause. According to CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1 is "not incompatible" with the GPL. Thanks to the many outside volunteers who have worked under Guido's direction to make these releases possible. B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON =============================================================== PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2 -------------------------------------------- 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights Reserved" are retained in Python alone or in any derivative version prepared by Licensee. 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python. 4. PSF is making Python available to Licensee on an "AS IS" basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this License Agreement. BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0 ------------------------------------------- BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1 1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization ("Licensee") accessing and otherwise using this software in source or binary form and its associated documentation ("the Software"). 2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by Licensee. 3. BeOpen is making the Software available to Licensee on an "AS IS" basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 5. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception, the "BeOpen Python" logos available at http://www.pythonlabs.com/logos.html may be used according to the permissions granted on that web page. 7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement. CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1 --------------------------------------- 1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 ("CNRI"), and the Individual or Organization ("Licensee") accessing and otherwise using Python 1.6.1 software in source or binary form and its associated documentation. 2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRI's License Agreement and CNRI's notice of copyright, i.e., "Copyright (c) 1995-2001 Corporation for National Research Initiatives; All Rights Reserved" are retained in Python 1.6.1 alone or in any derivative version prepared by Licensee. Alternately, in lieu of CNRI's License Agreement, Licensee may substitute the following text (omitting the quotes): "Python 1.6.1 is made available subject to the terms and conditions in CNRI's License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following URL: http://hdl.handle.net/1895.22/1013". 3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1. 4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS" basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS. 5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF. 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions. 7. This License Agreement shall be governed by the federal intellectual property law of the United States, including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginia's conflict of law provisions. Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party. 8. By clicking on the "ACCEPT" button where indicated, or by copying, installing or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement. ACCEPT CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2 -------------------------------------------------- Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. test-unit-3.6.2/README.md000066400000000000000000000064311456346657200147630ustar00rootroot00000000000000# test-unit [![Gem Version](https://badge.fury.io/rb/test-unit.png)](http://badge.fury.io/rb/test-unit) [![Build Status for Ruby 2.1+](https://github.com/test-unit/test-unit/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/test-unit/test-unit/actions/workflows/test.yml?query=branch%3Amaster+) * http://test-unit.github.io/ * https://github.com/test-unit/test-unit ## Description An xUnit family unit testing framework for Ruby. test-unit (Test::Unit) is unit testing framework for Ruby, based on xUnit principles. These were originally designed by Kent Beck, creator of extreme programming software development methodology, for Smalltalk's SUnit. It allows writing tests, checking results and automated testing in Ruby. test-unit ships as part of Ruby as a bundled gem. To check which version is included, see https://stdgems.org/test-unit/. It's only necessary to install the gem if you need a newer version. test-unit is the original Ruby unit testing library, and is still active. It is one of two unit testing libraries bundled with Ruby, the other being [minitest](https://github.com/minitest/minitest). When deciding which to use, consider: * test-unit is strict about backwards compatibility. A backwards-incompatible change would be considered a bug. * test-unit aims to support old Ruby versions, even if EOL. ## Features * test-unit 1.2.3 is the original test-unit, taken straight from the ruby distribution. It is being distributed as a gem to allow tool builders to use it as a stand-alone package. (The test framework in ruby is going to radically change very soon). * test-unit will be improved actively and may break compatibility with test-unit 1.2.3. (We will not hope it if it isn't needed.) * Some features exist as separated gems like GUI test runner. (Tk, GTK+ and Fox) test-unit-full gem package provides for installing all test-unit related gems easily. ## How To * [How To](https://github.com/test-unit/test-unit/blob/master/doc/text/how-to.md) (link for GitHub) * {file:doc/text/how-to.md How To} (link for YARD) ## Install 
% sudo gem install test-unit
If you want to use full test-unit features: 
% sudo gem install test-unit-full
## License This software is distributed under either the terms of new Ruby License or BSDL. See the file [COPYING](COPYING). Exception: * lib/test/unit/diff.rb is a triple license of (the new Ruby license or BSDL) and PSF license. ## Authors ### Active * Kouhei Sutou: The current maintainer * Haruka Yoshihara: Data driven test supports. ### Inactive * Nathaniel Talbott: The original author * Ryan Davis: The second maintainer ### Images * Mayu & Co.: kinotan icons ## Thanks * Daniel Berger: Suggestions and bug reports. * Designing Patterns: Suggestions. * Erik Hollensbe: Suggestions and bug reports. * Bill Lear: A suggestion. * Diego Pettenò: A bug report. * Angelo Lakra: A bug report. * Mike Pomraning: A bug report. * David MARCHALAND: Suggestions and bug reports. * Andrew Grimm: A bug report. * Champak Ch: A bug report. * Florian Frank: A bug report. * grafi-tt: Bug fixes and reports. * Jeremy Stephens: A bug report. * Hans de Graaff: Bug reports. * James Mead: A bug report. * Marc Seeger (Acquia): A bug report. * boutil: A bug report. * Vladislav Rassokhin: A bug report. test-unit-3.6.2/Rakefile000066400000000000000000000027111456346657200151460ustar00rootroot00000000000000# -*- ruby -*- # # Copyright (C) 2008-2017 Kouhei Sutou Encoding.default_internal = "UTF-8" if defined?(Encoding.default_internal) # TODO: Remove me when we drop Ruby 1.9 support. unless "".respond_to?(:b) class String def b dup.force_encoding("ASCII-8BIT") end end end require "erb" require "yaml" require "rubygems" require "rake/clean" require "yard" require "bundler/gem_helper" require "packnga" task :default => :test base_dir = File.dirname(__FILE__) helper = Bundler::GemHelper.new(base_dir) def helper.version_tag version end helper.install spec = helper.gemspec document_task = Packnga::DocumentTask.new(spec) do |task| task.original_language = "en" task.translate_languages = ["ja"] end Packnga::ReleaseTask.new(spec) do |task| test_unit_github_io_dir_candidates = [ "../../www/test-unit.github.io", ] test_unit_github_io_dir = test_unit_github_io_dir_candidates.find do |dir| File.directory?(dir) end task.index_html_dir = test_unit_github_io_dir end def rake(*arguments) ruby($0, *arguments) end task :test do ruby("test/run-test.rb") end namespace :doc do task :add_permalink do news_md = File.read("doc/text/news.md") applied_permalink = news_md.gsub(/(?
\[GitHub#(?\d+)\])(?!\()/) do
      "#{Regexp.last_match[:pre]}(https://github.com/test-unit/test-unit/issues/#{Regexp.last_match[:ref]})"
    end

    File.write("doc/text/news.md", applied_permalink)
  end
end
test-unit-3.6.2/doc/000077500000000000000000000000001456346657200142455ustar00rootroot00000000000000test-unit-3.6.2/doc/po/000077500000000000000000000000001456346657200146635ustar00rootroot00000000000000test-unit-3.6.2/doc/po/ja.po000066400000000000000000004345401456346657200156270ustar00rootroot00000000000000# ja.po for test-unit Reference.
# Copyright (C) 2011 Kouhei Sutou
# This file is distributed under the same license as the test-unit package.
# Kouhei Sutou , 2011.
msgid ""
msgstr ""
"Project-Id-Version: test-unit 2.3.1\n"
"PO-Revision-Date: 2017-03-31 17:13+0900\n"
"Last-Translator: Kouhei Sutou \n"
"Language-Team: Japanese\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

msgid "# test-unit"
msgstr ""

msgid ""
"[![](https://badge.fury.io/rb/test-unit.svg)](http://badge.fury.io/rb/test-uni"
"t)\n"
"[![](https://travis-ci.org/test-unit/test-unit.svg?branch=master)](https://tra"
"vis-ci.org/test-unit/test-unit)"
msgstr ""

msgid ""
"* https://test-unit.github.io/\n"
"* https://github.com/test-unit/test-unit"
msgstr ""

msgid "## Description"
msgstr "## 説明"

msgid "An xUnit family unit testing framework for Ruby."
msgstr ""

msgid ""
"test-unit (Test::Unit) is unit testing framework for Ruby, based on xUnit\n"
"principles. These were originally designed by Kent Beck, creator of extreme\n"
"programming software development methodology, for Smalltalk's SUnit. It allows"
"\n"
"writing tests, checking results and automated testing in Ruby."
msgstr ""

msgid "## Features"
msgstr ""

msgid ""
"* test-unit 1.2.3 is the original test-unit, taken\n"
"  straight from the ruby distribution. It is being\n"
"  distributed as a gem to allow tool builders to use it as a\n"
"  stand-alone package. (The test framework in ruby is going\n"
"  to radically change very soon)."
msgstr ""

msgid ""
"* test-unit will be improved actively and may break\n"
"  compatiblity with test-unit 1.2.3. (We will not hope it\n"
"  if it isn't needed.)"
msgstr ""

msgid ""
"* Some features exist as separated gems like GUI test\n"
"  runner. (Tk, GTK+ and Fox) test-unit-full gem package\n"
"  provides for installing all test-unit related gems\n"
"  easily."
msgstr ""

msgid "## How To"
msgstr "## 一歩進んだ使い方"

msgid ""
"* [How To](https://github.com/test-unit/test-unit/blob/master/doc/text/how-to."
"md) (link for GitHub)\n"
"* {file:doc/text/how-to.md How To} (link for YARD)"
msgstr ""

msgid "## Install"
msgstr "## インストール"

msgid ""
"
\n"
"% sudo gem install test-unit\n"
"
"
msgstr ""

msgid "If you want to use full test-unit features:"
msgstr ""

msgid ""
"
\n"
"% sudo gem install test-unit-full\n"
"
"
msgstr ""

msgid "## License"
msgstr ""

msgid "(The Ruby License)"
msgstr ""

msgid "This software is distributed under the same terms as ruby."
msgstr ""

msgid "Exception:"
msgstr ""

msgid ""
"  * lib/test/unit/diff.rb is a triple license of the Ruby license,\n"
"    PSF license and LGPLv2.1 or later."
msgstr ""

msgid ""
"  * lib/test-unit.rb is a dual license of the Ruby license and LGPLv2.1\n"
"    or later."
msgstr ""

msgid "## Authors"
msgstr ""

msgid "### Active"
msgstr ""

msgid ""
"* Kouhei Sutou: The current maintainer\n"
"* Haruka Yoshihara: Data driven test supports."
msgstr ""

msgid "### Inactive"
msgstr ""

msgid ""
"* Nathaniel Talbott: The original author\n"
"* Ryan Davis: The second maintainer"
msgstr ""

msgid "### Images"
msgstr ""

msgid "* Mayu & Co.: kinotan icons"
msgstr ""

msgid "## Thanks"
msgstr "## 感謝"

msgid ""
"* Daniel Berger: Suggestions and bug reports.\n"
"* Designing Patterns: Suggestions.\n"
"* Erik Hollensbe: Suggestions and bug reports.\n"
"* Bill Lear: A suggestion.\n"
"* Diego Pettenò: A bug report.\n"
"* Angelo Lakra: A bug report.\n"
"* Mike Pomraning: A bug report.\n"
"* David MARCHALAND: Suggestions and bug reports.\n"
"* Andrew Grimm: A bug report.\n"
"* Champak Ch: A bug report.\n"
"* Florian Frank: A bug report.\n"
"* grafi-tt: Bug fixes and reports.\n"
"* Jeremy Stephens: A bug report.\n"
"* Hans de Graaff: Bug reports.\n"
"* James Mead: A bug report.\n"
"* Marc Seeger (Acquia): A bug report.\n"
"* boutil: A bug report.\n"
"* Vladislav Rassokhin: A bug report."
msgstr ""

msgid "## 1. First step of the `test-unit`"
msgstr "## 1. `test-unit`はじめの一歩"

msgid "Let's getting start `test-unit`."
msgstr "テストユニットを使ってみましょう。"

msgid ""
"This document creates an example gem package called `sample` with the `test-un"
"it` testing framework."
msgstr "この文書は`sample`というgemパッケージを作成し`test-unit`を利用する方法について解説します。"

msgid "## 2. Install bundler and test-unit."
msgstr "## 2. bundlerとtest-unitのインストール"

msgid ""
"* First, install the `bundler` gem for generating gem template.\n"
"* Second, install the `test-unit` itself."
msgstr ""
"* 最初にgemの雛形を生成する`bundler`をインストールします。\n"
"* 次に、`test-unit`をインストールします。"

msgid ""
"~~~\n"
"!!!plain\n"
"gem install bundler\n"
"gem install test-unit\n"
"~~~"
msgstr ""

msgid ""
"The `gem list` command output installed packages.\n"
"You will find the following lines."
msgstr ""
"`gem list`コマンドでインストールしたパッケージを確認します。\n"
"インストールが成功すると、次のような行が出力されます。"

msgid ""
"~~~\n"
"!!!plain\n"
"gem list\n"
"...\n"
"bundler (1.14.6)\n"
"...\n"
"test-unit (3.2.3)\n"
"~~~"
msgstr ""

msgid "## 3. Create gem template."
msgstr "## 3. gemテンプレートの作成"

msgid ""
"Next, create a gem template using `bundler` command.\n"
"This command generates package skeleton with a testing framework.\n"
"However, this command can't generate test templates for `test-unit`."
msgstr ""
"次に`bundler`コマンドを使ってgemの雛形を作成します。\n"
"このコマンドはテストに必要な雛形も生成することができますが、\n"
"現在は、`test-unit`のためのテンプレートを生成することはできません。"

msgid ""
"So, First create gem template with the `minitest` testing framework.\n"
"(It's similar to `unit-test`).\n"
"After that, replace some files for `test-unit`."
msgstr ""
"そのため、まず`minitest`というテストフレームワークのテンプレートを作成し\n"
"(このフレームワークは`unit-test`に似ています。)\n"
"その後いくつかのファイルを`test-unit`用に修正します。"

msgid "The `bundle gem -t minitest sample` command will generate the following files."
msgstr "`bundle gem -t minitest sample`を実行すると次のファイルを生成します。"

msgid ""
"~~~\n"
"!!!plain\n"
".\n"
"|-- Gemfile\n"
"|-- README.md\n"
"|-- Rakefile\n"
"|-- bin\n"
"|   |-- console\n"
"|   `-- setup\n"
"|-- lib\n"
"|   |-- sample\n"
"|   |   `-- version.rb\n"
"|   `-- sample.rb\n"
"|-- sample.gemspec  # <- Modify\n"
"`-- test\n"
"    |-- sample_test.rb # <- Modify\n"
"    `-- test_helper.rb # <- Modify\n"
"~~~"
msgstr ""
"~~~\n"
"!!!plain\n"
".\n"
"|-- Gemfile\n"
"|-- README.md\n"
"|-- Rakefile\n"
"|-- bin\n"
"|   |-- console\n"
"|   `-- setup\n"
"|-- lib\n"
"|   |-- sample\n"
"|   |   `-- version.rb\n"
"|   `-- sample.rb\n"
"|-- sample.gemspec  # <- 修正\n"
"`-- test\n"
"    |-- sample_test.rb # <- 修正\n"
"    `-- test_helper.rb # <- 修正\n"
"~~~"

msgid "## 4. Edit files for `test-unit`"
msgstr "## 4. `test-unit`用にファイルを修正する"

msgid "### 4.1. Edit gemspec"
msgstr "### 4.1 gemspecの編集"

msgid ""
"Edit `sample.gemspec` like the below.\n"
"Replace `minitest` line to `test-unit`."
msgstr ""
"`sample.gemspec`ファイルを次のように修正します。\n"
"`minitest`の行を、`test-unit`に修正します。"

msgid "Before"
msgstr "修正前"

msgid ""
"~~~\n"
"!!!ruby\n"
"  spec.add_development_dependency \"minitest\", \"~> 5.0\"\n"
"~~~"
msgstr ""

msgid "After"
msgstr "修正後"

msgid ""
"~~~\n"
"!!!ruby\n"
"  spec.add_development_dependency \"test-unit\", \"~> 3.2.3\"\n"
"~~~"
msgstr ""

msgid "### 4.2. Edit `test/test_helper.rb`"
msgstr "### 4.2 `test/test_helper.rb`の修正"

msgid "Next, edit the `test/test_helper.rb` file."
msgstr "次に`test/test_helper`ファイルを修正します。"

msgid ""
"~~~\n"
"!!!ruby\n"
"$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)\n"
"require 'sample'"
msgstr ""

msgid ""
"require 'minitest/autorun' # <-- Modify this line.\n"
"~~~"
msgstr ""
"require 'minitest/autorun' # <-- この行を修正します。\n"
"~~~"

msgid ""
"require 'test/unit' # <-- After modification.\n"
"~~~"
msgstr ""
"require 'test/unit' # <-- 修正後\n"
"~~~"

msgid "### 4.3 Rakefile (No edit)"
msgstr "### 4.3 Rakefile(修正不要)"

msgid ""
"This file doesn't need to modify.\n"
"The output is the below."
msgstr ""
"このファイルは修正不要です。\n"
"ファイルの中身は次のようになっています。"

msgid ""
"~~~\n"
"!!!ruby\n"
"require \"bundler/gem_tasks\"\n"
"require \"rake/testtask\""
msgstr ""

msgid ""
"Rake::TestTask.new(:test) do |t|\n"
"  t.libs << \"test\"\n"
"  t.libs << \"lib\"\n"
"  t.test_files = FileList['test/**/*_test.rb']\n"
"end"
msgstr ""
"Rake::TestTask.new(:test) do |t|\n"
"  t.libs << \"test\"\n"
"  t.libs << \"lib\"\n"
"  t.test_files = FileList['test/**/*_test.rb']\n"
"end"

msgid ""
"task :default => :test\n"
"~~~"
msgstr ""

msgid "### 4.4 Edit `test/sample_test.rb`"
msgstr "### 4.4 `test/sample_test.rb`の修正"

msgid ""
"The bundler generate the file `test/sample_test.rb`.\n"
"This file originally templates for `minitest`."
msgstr ""
"bundlerコマンドは、`test/sample_test.rb`を作成します。\n"
"このファイルは`minitest`用のテンプレートになっています。"

msgid "Let's modify this file for `test-unit`"
msgstr "`test-unit`用に修正します"

msgid "before"
msgstr "修正前"

msgid ""
"~~~\n"
"!!!ruby\n"
"require 'test_helper'"
msgstr ""

msgid ""
"class SampleTest < Minitest::Test # <- Modify here\n"
"  def test_that_it_has_a_version_number\n"
"    refute_nil ::Sample::VERSION\n"
"  end"
msgstr ""
"class SampleTest < Minitest::Test # <- ここを修正します\n"
"  def test_that_it_has_a_version_number\n"
"    refute_nil ::Sample::VERSION\n"
"  end"

msgid ""
"  def test_it_does_something_useful\n"
"    assert false\n"
"  end\n"
"end\n"
"~~~"
msgstr ""

msgid ""
"class SampleTest < Test::Unit::TestCase # <- After modification\n"
"  def test_that_it_has_a_version_number\n"
"    refute_nil ::Sample::VERSION\n"
"  end"
msgstr ""
"class SampleTest < Test::Unit::TestCase # <- 修正後\n"
"  def test_that_it_has_a_version_number\n"
"    refute_nil ::Sample::VERSION\n"
"  end"

msgid "## 5. Execute test."
msgstr "## 5. テストの実行"

msgid ""
"The `rake test` command execute test scenarios in the `test` directory.\n"
"Now it tries to two tests. One will success the other one fails."
msgstr ""
"`rake test`コマンドを実行すると`test`ディレクトリの下にあるテストを実行します。\n"
"二つのテストを実行し、一つは成功、もう一つは失敗します。"

msgid ""
"~~~\n"
"!!!plain\n"
"rake test\n"
"Loaded suite\n"
"/path/to/ruby/lib/ruby/gems/2.3.0/gems/rake-12.0.0/lib/rake/rake_test_loader\n"
"Started\n"
"F\n"
"=============================================================================="
"==\n"
"Failure:  is not true.\n"
"test_it_does_something_useful(SampleTest)\n"
"/path/to/sample/test/sample_test.rb:9:in `test_it_does_something_useful'\n"
"      6:   end\n"
"      7:\n"
"      8:   def test_it_does_something_useful\n"
"  =>  9:     assert false\n"
"     10:   end\n"
"     11: end\n"
"=============================================================================="
"==\n"
"."
msgstr ""

msgid ""
"Finished in 0.011521 seconds.\n"
"------------------------------------------------------------------------------"
"--\n"
"2 tests, 2 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifi"
"cations\n"
"50% passed\n"
"------------------------------------------------------------------------------"
"--\n"
"173.60 tests/s, 173.60 assertions/s\n"
"rake aborted!\n"
"Command failed with status (1)"
msgstr ""

msgid ""
"Tasks: TOP => test\n"
"(See full trace by running task with --trace)\n"
"~~~"
msgstr ""

msgid "## 6. Create original tests."
msgstr "## 6. オリジナルのテストを作る"

msgid "Let's create your original tests with the following rules."
msgstr "次のルールに従ってオリジナルのテストを作成します。"

msgid ""
"* Create a test file in the `test` directory.\n"
"* The file needs suffix  `xxx_test.rb`.\n"
"* You can put test file into the subdirectory like `test/sub`."
msgstr ""
"* `test`ディレクトリの下にテストを作成します。\n"
"* ファイルの名前は、xxx_test.rbのようにします。\n"
"* テストは`sub/test`のようなサブディレクトリに置くこともできます。"

msgid "Example directory layout."
msgstr "ディレクトリレイアウトの例"

msgid ""
"~~~\n"
"!!!plain\n"
"test\n"
"|-- sample_test.rb\n"
"|-- sub\n"
"|   `-- sample2_test.rb\n"
"`-- test_helper.rb\n"
"~~~"
msgstr ""

msgid "Example test file in the sub directory."
msgstr "サブディレクトリ内のテスト例"

msgid ""
"module Sub\n"
"  class Sample2Test < Test::Unit::TestCase\n"
"    def test_that_it_has_a_version_number\n"
"      refute_nil ::Sample::VERSION\n"
"    end"
msgstr ""
"module Sub\n"
"  class Sample2Test < Test::Unit::TestCase\n"
"    def test_that_it_has_a_version_number\n"
"      refute_nil ::Sample::VERSION\n"
"    end"

msgid ""
"    def test_it_does_something_useful\n"
"      assert false\n"
"    end\n"
"  end\n"
"end\n"
"~~~"
msgstr ""

msgid "## 7. For more information"
msgstr "## 7. 詳細な情報"

msgid "Let's read the official document."
msgstr "公式のドキュメントを参照してください。"

msgid "* [test-unit](https://test-unit.github.io/index.html)"
msgstr "* [test-unit](https://test-unit.github.io/index.html)"

msgid "# How To"
msgstr "# 一歩進んだ使い方"

msgid "## Run all tests"
msgstr "## すべてのテストを実行する"

msgid ""
"To make it easy to run all your tests, you can add a `run_test.rb` script\n"
"to your `test` directory. A simple example might look like:"
msgstr "すべてのテストを簡単に実行するために、 `run_test.rb` スクリプトを `test` ディレクトリにおきます。スクリプトは以下のようにします。"

msgid ""
"    base_dir = File.expand_path(File.join(File.dirname(__FILE__), \"..\"))\n"
"    lib_dir  = File.join(base_dir, \"lib\")\n"
"    test_dir = File.join(base_dir, \"test\")"
msgstr ""

msgid "    $LOAD_PATH.unshift(lib_dir)"
msgstr ""

# Test::Unit
msgid "    require 'test/unit'"
msgstr ""

msgid "    exit Test::Unit::AutoRunner.run(true, test_dir)"
msgstr ""

msgid "Then it's easy to run tests via the command line with,"
msgstr "これで以下のコマンドで簡単にテストを実行できます。"

msgid "    $ ruby test/run_test.rb"
msgstr ""

msgid "## Change test runner via the command line"
msgstr "## コマンドラインでテストランナーを変更する"

msgid ""
"The output format can be changed via the command line with\n"
"the `--runner` option. Simply tack it to the end:"
msgstr "テスト結果の出力フォーマットはコマンドラインで `--runner` オプションを指定すると変更できます。単純にこのオプションを最後に追加してください。"

msgid "    ruby test/run_test.rb --runner tap"
msgstr ""

msgid "## Configure test-unit per-project"
msgstr "## プロジェクトごとにtest-unitを設定する"

msgid ""
"Test::Unit reads `test-unit.yml` or `.test-unit.yml` in the current working\n"
"directory as Test::Unit's configuration file. It can contain the following\n"
"settings:"
msgstr ""
"Test::Unitは `test-unit.yml` または現在のワーキングディレクトリにある `.test-unit.yml` をTest::Unitの"
"設定ファイルとして読み込みます。このファイルには以下のような設定をすることができます。"

# Test::Unit
msgid ""
"* color scheme definitions\n"
"* test runner to be used\n"
"* test runner options\n"
"* test collector to be used"
msgstr ""

msgid ""
"Except color scheme definitions, all of them can be specified by command\n"
"line option."
msgstr "カラースキーム定義以外はコマンドラインオプションで指定することができます。"

msgid "Here are sample color scheme definitions:"
msgstr "以下はカラースキームの定義例です。"

msgid ""
"    color_schemes:\n"
"      inverted:\n"
"        success:\n"
"          name: red\n"
"          bold: true\n"
"        failure:\n"
"          name: green\n"
"          bold: true\n"
"      other_scheme:\n"
"        ..."
msgstr ""

msgid "Here are the syntax of color scheme definitions:"
msgstr ""

msgid ""
"    color_schemes:\n"
"      SCHEME_NAME:\n"
"        EVENT_NAME:\n"
"          name: COLOR_NAME\n"
"          intensity: BOOLEAN\n"
"          bold: BOOLEAN\n"
"          italic: BOOLEAN\n"
"          underline: BOOLEAN\n"
"        ...\n"
"      ..."
msgstr ""

msgid ""
"| Definition  | Description                  |\n"
"|-------------|------------------------------|\n"
"| SCHEME_NAME | the name of the color scheme |\n"
"| EVENT_NAME  | success, failure, pending, omission, notification, error |\n"
"| COLOR_NAME  | black, red, green, yellow, blue, magenta, cyan, white    |\n"
"| BOOLEAN     | true or false |"
msgstr ""

msgid ""
"You can use the above 'inverted' color scheme with the following configuration"
":"
msgstr "上で定義した'inverted'カラースキムを使う設定は以下の通りです。"

msgid ""
"    runner: console\n"
"    console_options:\n"
"      color_scheme: inverted\n"
"    color_schemes:\n"
"      inverted:\n"
"        success:\n"
"          name: red\n"
"          bold: true\n"
"        failure:\n"
"          name: green\n"
"          bold: true"
msgstr ""

msgid "# News"
msgstr ""

msgid "## 3.3.3 - 2019-05-10 {#version-3-3-3}"
msgstr ""

#, fuzzy
msgid "### Fixed"
msgstr "### 修正"

msgid ""
"  * Fixed a bug that priority mode with test case name that uses\n"
"    special characters such as `?` can't be used on Windows."
msgstr ""

msgid "## 3.3.2 - 2019-04-11 {#version-3-3-2}"
msgstr ""

msgid "### Fixes"
msgstr "### 修正"

msgid ""
"  * Fixed a bug that `Test::Unit::Collector::Load` doesn't load test\n"
"    files under sub directories when these files have the same base\n"
"    name as test files in upper directories.\n"
"    [Reported by Kenta Murata]"
msgstr ""

msgid "### Thanks"
msgstr "### 感謝"

msgid "  * Kenta Murata"
msgstr ""

msgid "## 3.3.1 - 2019-03-27 {#version-3-3-1}"
msgstr ""

msgid "### Improvements"
msgstr "### 改良"

msgid ""
"  * Added support for `Test::Unit::AssertionFailedError#user_message`\n"
"    for not only `assert_equal` and `assert_raise` but also all\n"
"    assertions.\n"
"    [GitHub#162][Reported by xgraffm]"
msgstr ""

msgid "  * xgraffm"
msgstr ""

msgid "## 3.3.0 - 2019-01-23 {#version-3-3-0}"
msgstr ""

msgid ""
"  * Added support for auto test run when all tests are defined in\n"
"    modules."
msgstr ""

msgid ""
"  * Added support for defining methods to test case class in multiple\n"
"    threads.\n"
"    [GitHub#159][Reported by Charles Oliver Nutter]"
msgstr ""

msgid ""
"  * Suppressed warnings on Ruby 2.5.\n"
"    [GitHub#160][Reported by Daniel Berger]"
msgstr ""

msgid "  * Suppressed warnings on Ruby 2.7."
msgstr ""

msgid ""
"  * Fixed a code snippet fetch failure when source code isn't UTF-8\n"
"    and the default external encoding is set to not UTF-8.\n"
"    [GitHub#161][Reported by masa kunikata]"
msgstr ""

msgid "  * Charles Oliver Nutter"
msgstr ""

msgid "  * Daniel Berger"
msgstr ""

msgid "  * masa kunikata"
msgstr ""

msgid "## 3.2.9 - 2018-12-01 {#version-3-2-9}"
msgstr ""

msgid ""
"  * Added support for data generation by method. `data_#{test_name}`\n"
"    is called to generate data for `test_name` test."
msgstr ""

msgid "  * Added support for data matrix generation."
msgstr ""

msgid "    Example:"
msgstr ""

msgid ""
"    ```ruby\n"
"    data(:a, [0, 1, 2])\n"
"    data(:b, [:x, :y])\n"
"    def test_data(data)\n"
"    end\n"
"    ```"
msgstr ""

msgid "    This example generates the following data matrix:"
msgstr ""

msgid ""
"      * label: `\"a: 0, b: :x\"`, data: `{a: 0, b: :x}`\n"
"      * label: `\"a: 0, b: :y\"`, data: `{a: 0, b: :y}`\n"
"      * label: `\"a: 1, b: :x\"`, data: `{a: 1, b: :x}`\n"
"      * label: `\"a: 1, b: :y\"`, data: `{a: 1, b: :y}`\n"
"      * label: `\"a: 2, b: :x\"`, data: `{a: 2, b: :x}`\n"
"      * label: `\"a: 2, b: :y\"`, data: `{a: 2, b: :y}`"
msgstr ""

msgid "  * Added `Test::Unit::TestCase#data` that returns the current data."
msgstr ""

msgid ""
"  * Added support for using test method that doesn't have no\n"
"    parameters as data driven test."
msgstr ""

msgid ""
"    ```ruby\n"
"    data(\"label\", :value)\n"
"    def test_data # Available since this release\n"
"      p data # :value\n"
"    end\n"
"    ```"
msgstr ""

msgid "  * Added support for `:keep` option to `Test::Unit::TestCase.data`."
msgstr ""

msgid ""
"  * Added support for `:group` option to\n"
"    `Test::Unit::TestCase.data`. It's useful to generate multiple data\n"
"    matrix groups."
msgstr ""

msgid ""
"    ```ruby\n"
"    # Group1\n"
"    data(:a, [0, 1, 2], group: :g1)\n"
"    data(:b, [:x, :y], group: :g1)\n"
"    # Group2\n"
"    data(:a, [:x, :y], group: :g2)\n"
"    data(:c, [-1, -2], group: :g2)\n"
"    def test_data(data)\n"
"    end\n"
"    ```"
msgstr ""

msgid ""
"      * label: `\"group: :g1, a: 0, b: :x\"`, data: `{a: 0, b: :x}`\n"
"      * label: `\"group: :g1, a: 0, b: :y\"`, data: `{a: 0, b: :y}`\n"
"      * label: `\"group: :g1, a: 1, b: :x\"`, data: `{a: 1, b: :x}`\n"
"      * label: `\"group: :g1, a: 1, b: :y\"`, data: `{a: 1, b: :y}`\n"
"      * label: `\"group: :g1, a: 2, b: :x\"`, data: `{a: 2, b: :x}`\n"
"      * label: `\"group: :g1, a: 2, b: :y\"`, data: `{a: 2, b: :y}`\n"
"      * label: `\"group: :g2, a: :x, b: -1\"`, data: `{a: :x, b: -1}`\n"
"      * label: `\"group: :g2, a: :x, b: -2\"`, data: `{a: :x, b: -2}`\n"
"      * label: `\"group: :g2, a: :y, b: -1\"`, data: `{a: :y, b: -1}`\n"
"      * label: `\"group: :g2, a: :y, b: -2\"`, data: `{a: :y, b: -2}`"
msgstr ""

msgid "## 3.2.8 - 2018-05-13 {#version-3-2-8}"
msgstr ""

msgid ""
"  * [UI][console]: Changed to put code snippet before backtrace on\n"
"    reverse mode."
msgstr ""

msgid "## 3.2.7 - 2017-12-12 {#version-3-2-7}"
msgstr ""

msgid ""
"  * Added source code link to gemspec.\n"
"    [GitHub#157][Patch by Grey Baker]"
msgstr ""

msgid ""
"  * Changed to use SVG image for badges in README.\n"
"    [GitHub#158][Patch by Olle Jonsson]"
msgstr ""

msgid ""
"  * [UI][console]: Added `--reverse-output` option to output fault\n"
"    details in reverse like Ruby 2.5. It's enabled by default only for\n"
"    tty output."
msgstr ""

msgid ""
"  * Fixed a typo.\n"
"    [GitHub#156][Patch by masa kunikata]"
msgstr ""

msgid "  * [UI][console]: Fixed a bug that broken align in verbose mode."
msgstr ""

msgid "  * Grey Baker"
msgstr ""

msgid "  * Olle Jonsson"
msgstr ""

msgid "## 3.2.6 - 2017-09-21 {#version-3-2-6}"
msgstr ""

msgid ""
"  * Changed test file require failure to error from omission.\n"
"    [GitHub#154][Patch by naofumi-fujii]"
msgstr ""

msgid "  * naofumi-fujii"
msgstr ""

msgid "## 3.2.5 - 2017-06-24 {#version-3-2-5}"
msgstr ""

msgid ""
"  * Supported `--enable-frozen-string-literal` `ruby` option.\n"
"    [GitHub#149][Reported by Pat Allan]"
msgstr ""

msgid "  * Pat Allan"
msgstr ""

msgid "## 3.2.4 - 2017-05-23 {#version-3-2-4}"
msgstr ""

msgid "  * Updated tests for Ruby 2.4. [GitHUb#136][Patch by Kazuki Tsujimoto]"
msgstr ""

msgid "  * Supported power\\_assert 1.0.0. [GitHub#137][Patch by Kazuki Tsujimoto]"
msgstr ""

msgid ""
"  * Added the getting started document.\n"
"    [GitHub#139][GitHub#141][Patch by Hiroyuki Sato]"
msgstr ""

msgid ""
"  * Added the document for `attribute`.\n"
"    [GitHub#143][Patch by Fumiaki MATSUSHIMA]"
msgstr ""

msgid "  * Improved a link for GitHub. [GitHub#144][Patch by rochefort]"
msgstr ""

msgid "  * Updated `.travis.yml`. [GitHub#145][Patch by Jun Aruga]"
msgstr ""

msgid "  * Fixed a contributor name. [GitHub#131][Patch by Akira Matsuda]"
msgstr ""

msgid "  * Fixed typos in document. [GitHub#132][Patch by Akira Matsuda]"
msgstr ""

msgid "  * Fixed typos in document. [GitHub#134][Patch by Yuji Yaginuma]"
msgstr ""

msgid ""
"  * Fixed a bug that data label with \"(\" isn't supported.\n"
"    [GitHub#135][Reported by Kazuki Tsujimoto]"
msgstr ""

msgid ""
"  * Fixed assertion message in English.\n"
"    [GitHub#133][Reported by Khalil Fazal]"
msgstr ""

msgid "  * Fixed a typo in typo fix. [GitHub#138][Patch by kami]"
msgstr ""

msgid ""
"  * Fixed a bug that target location finder may return wrong\n"
"    location. [GitHub#146][Patch by Yuki Ito]"
msgstr ""

msgid ""
"  * Fixed a bug that `--no-show-detail-immediately` raises an error.\n"
"    [GitHub#147][Reported by MSP-Greg]"
msgstr ""

msgid "  * Akira Matsuda"
msgstr ""

msgid "  * Yuji Yaginuma"
msgstr ""

msgid "  * Kazuki Tsujimoto"
msgstr ""

msgid "  * Khalil Fazal"
msgstr ""

msgid "  * kami"
msgstr ""

msgid "  * Hiroyuki Sato"
msgstr ""

msgid "  * Fumiaki MATSUSHIMA"
msgstr ""

msgid "  * rochefort"
msgstr ""

msgid "  * Jun Aruga"
msgstr ""

msgid "  * Yuki Ito"
msgstr ""

msgid "  * MSP-Greg"
msgstr ""

msgid "## 3.2.3 - 2016-11-25 {#version-3-2-3}"
msgstr ""

msgid ""
"  * Fixed a bug that `--order` isn't applied.\n"
"    [GitHub#129][Reported by Vít Ondruch]"
msgstr ""

msgid "  * Vít Ondruch"
msgstr ""

msgid "## 3.2.2 - 2016-11-02 {#version-3-2-2}"
msgstr ""

msgid ""
"  * Improved Travis CI configuration.\n"
"    [GitHub#123][Patch by Ryunosuke Sato]"
msgstr ""

msgid ""
"  * Supported Java native exception.\n"
"    [GitHub#126][Reported by Bob Saveland]"
msgstr ""

msgid "  * doc: Fixed markup. [GitHub#127][Patch by Tomohiro Hashidate]"
msgstr ""

msgid ""
"  * Fixed a bug that `--location=LINE` may not detect a test when\n"
"    fixtures are defined before any tests:"
msgstr ""

msgid ""
"        1 class MyTestCase < Test::Unit::TestCase\n"
"        2   setup do\n"
"        3   end\n"
"        4\n"
"        5   test \"xxx\" do\n"
"        6   end\n"
"        7 end"
msgstr ""

msgid "    `--location=5` couldn't find the `xxx` test."
msgstr ""

msgid "    [Reported by Ryota Sasabe]"
msgstr ""

msgid "  * Ryunosuke Sato"
msgstr ""

msgid "  * Tomohiro Hashidate"
msgstr ""

msgid "  * Bob Saveland"
msgstr ""

msgid "  * Ryota Sasabe"
msgstr ""

msgid "## 3.2.1 - 2016-07-19 {#version-3-2-1}"
msgstr ""

msgid ""
"  * Clarified lib/test/unit/diff.rb license. It's a triple license of\n"
"    the Ruby license, PSF license and LGPLv2.1 or later.\n"
"    [Reported by Luisa Pace]"
msgstr ""

msgid ""
"  * Reported norification when data driven test doesn't have\n"
"    parameter.\n"
"    [GitHub#122][Reported by Satoshi \"Moris\" Tagomori]"
msgstr ""

msgid "  * Luisa Pace"
msgstr ""

msgid "  * Satoshi \"Moris\" Tagomori"
msgstr ""

msgid "## 3.2.0 - 2016-06-12 {#version-3-2-0}"
msgstr ""

msgid ""
"  * Supported rxvt family terminals as color available terminals.\n"
"    [GitHub#121][Reported by Ippei Kishida]"
msgstr ""

msgid "  * Ippei Kishida"
msgstr ""

msgid "## 3.1.9 - 2016-05-20 {#version-3-1-9}"
msgstr ""

msgid ""
"  * Fixed conflict with test-unit-power_assert.\n"
"    [GitHub#120][Patch by Kazuki Tsujimoto]"
msgstr ""

msgid "  * Fixed a bug that path in `$LOAD_PATH` may be removed."
msgstr ""

msgid "## 3.1.8 - 2016-03-19 {#version-3-1-8}"
msgstr ""

msgid ""
"  * Added `--stop-on-failure` command line option. With this option,\n"
"    running test suite is stopped immediately when one test is failed\n"
"    or an error is raised in one test."
msgstr ""

msgid "## 3.1.7 - 2016-01-17 {#version-3-1-7}"
msgstr ""

msgid " * Added a missing require."
msgstr ""

msgid "## 3.1.6 - 2016-01-17 {#version-3-1-6}"
msgstr ""

msgid "It's a Ruby on Rails integration improvement release."
msgstr "Railsと一緒に使いやすくなったリリースです。"

msgid ""
"  * Filtered backtrace of power\\_assert.\n"
"    [GitHub#114]\n"
"  * Improved performance to retrieve test defined location.\n"
"  * Improved performance to run fixtures in a test.\n"
"  * Supported running a test by `yield` in `setup`:"
msgstr ""

msgid "    Before:"
msgstr ""

msgid ""
"        def setup\n"
"          @file = File.open(\"x\")\n"
"        end"
msgstr ""

msgid ""
"        def teardown\n"
"          @file.close\n"
"        end"
msgstr ""

msgid "    After:"
msgstr ""

msgid ""
"        def setup\n"
"          File.open(\"x\") do |file|\n"
"            @file = file\n"
"            yield\n"
"          end\n"
"        end"
msgstr ""

msgid ""
"  * Added `--default-test-path` option that specifies the default path\n"
"    that has tests.\n"
"  * Made auto runner registration more lazily. Auto runner isn't\n"
"    registered automatically until user defines a test. In the\n"
"    previous releases, auto runner is registered automatically when\n"
"    user defines a test case.\n"
"  * Supported specifying a test by location in command line. For\n"
"    example, the following command line runs a test that is defined in\n"
"    /tmp/test_a.rb at line 10:"
msgstr ""

msgid "        % ruby -r test-unit -e run_test /tmp/test_a.rb:10"
msgstr ""

msgid ""
"  * Fixed a bug that test isn't ran. The test has the same name as\n"
"    data driven test that is defined in parent test case.\n"
"    [GitHub#115]"
msgstr ""

msgid "## 3.1.5 - 2015-10-09 {#version-3-1-5}"
msgstr ""

msgid "It's a Rack integration improvement release."
msgstr "Rackと一緒に使いやすくなったリリースです。"

msgid ""
"  * Renamed experimental top-level `run` method to `run_test` method\n"
"    because `run` is conflicted with Rack.\n"
"    [GitHub#32][GitHub:basecamp/pow#303] [Reported by Yevhen Viktorov]"
msgstr ""

msgid "  * Yevhen Viktorov"
msgstr ""

msgid "## 3.1.4 - 2015-09-26 {#version-3-1-4}"
msgstr ""

msgid "It's a minor improvement release."
msgstr "微改良リリースです。"

msgid ""
"  * Updated sample code. [GitHub#109][Patch by takiy33]\n"
"  * Updated .travis.yml. [GitHub#110][Patch by takiy33]\n"
"  * document: Added table header in how to document.\n"
"    [GitHub#111][Patch by takiy33]\n"
"  * Removed duplicated code.\n"
"    [GitHub#112][Patch by takiy33]\n"
"  * Removed needless encoding conversion in fetching code snippet.\n"
"    [GitHub#113][Patch by NARUSE, Yui]"
msgstr ""

msgid ""
"  * takiy33\n"
"  * NARUSE, Yui"
msgstr ""

msgid "## 3.1.3 - 2015-07-26 {#version-3-1-3}"
msgstr ""

msgid "It's a bug fix release."
msgstr "バグフィックスリリースです。"

msgid "  * Removed unused `TODO` file. [GitHub#108][Patch by takiy33]"
msgstr ""

msgid ""
"  * `--location`: Fixed a bug that `--location LINE` doesn't work when\n"
"    test script is specified as relative path. [Reported by TOMITA Masahiro]"
msgstr ""

msgid "    The following doesn't work:"
msgstr ""

msgid "        % ruby ./test.rb --location 10"
msgstr ""

msgid "    The following works:"
msgstr ""

msgid "        % ruby test.rb --location 10"
msgstr ""

msgid ""
"  * takiy33\n"
"  * TOMITA Masahiro"
msgstr ""

msgid "## 3.1.2 - 2015-06-09 {#version-3-1-2}"
msgstr ""

msgid "It's command line option improvements fix release."
msgstr ""

msgid ""
"  * `--location`: Made path match rule more strict.\n"
"    [Suggested by kimura wataru]\n"
"    * Before:\n"
"      * If test defined path ends with the specified path, the test is\n"
"        matched.\n"
"    * After:\n"
"      * If base name of test defined path equals to the specified\n"
"        path, the test is matched.\n"
"      * If relative path of test defined path equals to the specified\n"
"        path, the test is matched.\n"
"      * If the specified path is absolute path and test defined path\n"
"        equals to the specified path, the test is matched.\n"
"  * `--pattern`: If the option is specified, the default patterns\n"
"    aren't used. In the earlier versions, both the default patterns\n"
"    and the specified patterns are used.\n"
"    [Suggested by kimura wataru]"
msgstr ""

msgid "  * kimura wataru"
msgstr ""

msgid "## 3.1.1 - 2015-05-29 {#version-3-1-1}"
msgstr ""

msgid ""
"  * Fixed a bug that `--location` detects tests not only in sub test\n"
"    case but also parent test case.\n"
"    [GitHub#105][Reported by wanabe]"
msgstr ""

msgid "  * wanabe"
msgstr ""

msgid "## 3.1.0 - 2015-05-28 {#version-3-1-0}"
msgstr ""

msgid "  * [ui][console] Removed needless new line."
msgstr ""

msgid ""
"  * Fixed a bug that priority mode can't be used on Windows.\n"
"    [GitHub#95][Reported by Daniel Berger]\n"
"  * Fixed a homepage URL RubyGems spec.\n"
"    [GitHub#96][Patch by Masayoshi Takahashi]\n"
"    supported.) [GitHub#89][Patch by Aaron Stone]\n"
"  * Fixed a bug that shutdown hook isn't called when pass throw\n"
"    exception such as `Interrupt` is raised.\n"
"    [GitHub#98][Reported by jeremiahishere.]\n"
"  * Fixed typos in documents.\n"
"    [GitHub#100][Reported by scivola]\n"
"    [GitHub#102][GitHub#103][Patch by Masafumi Yokoyama]\n"
"  * Fixed a bug that the same name test isn't executed in sub test case.\n"
"    [GitHub#104][Reported by wanabe]"
msgstr ""

msgid ""
"  * Daniel Berger\n"
"  * Masayoshi Takahashi\n"
"  * jeremiahishere\n"
"  * scivola\n"
"  * Masafumi Yokoyama\n"
"  * wanabe"
msgstr ""

msgid "## 3.0.9 - 2014-12-31 {#version-3-0-9}"
msgstr ""

msgid "It's a release that improves colors."
msgstr ""

msgid ""
"  * Added a work around for Ruby 1.8. (Note: Ruby 1.8 isn't\n"
"    supported.) [GitHub#89][Patch by Aaron Stone]\n"
"  * Supported colorized output on Windows.\n"
"    [GitHub#90][Patch by usa]\n"
"  * Improved colorized output.\n"
"    http://www.a-k-r.org/d/2014-12.html#a2014_12_27_1\n"
"    [Suggested by Tanaka Akira]"
msgstr ""

msgid ""
"  * Aaron Stone\n"
"  * usa\n"
"  * Tanaka Akira"
msgstr ""

msgid "## 3.0.8 - 2014-12-12 {#version-3-0-8}"
msgstr ""

msgid "It's a release that supports Ruby 2.2.0 preview2."
msgstr ""

msgid ""
"  * Added a link for YARD in README.\n"
"    [GitHub:test-unit.github.io#2][Reported by sunnyone]\n"
"  * Added description about \"/PATTERN/\" style value in auto runner usage.\n"
"    [GitHub#86][Suggested by sunnyone]\n"
"  * Supported Ruby 2.2.0 preview2 in `assert_throw` and\n"
"    `assert_nothing_thrown`."
msgstr ""

msgid ""
"  * Fixed a bug that error report is failed when source encoding and\n"
"    locale encoding are different.\n"
"    [GitHub#87][Reported by scivola]"
msgstr ""

msgid ""
"  * sunnyone\n"
"  * scivola"
msgstr ""

msgid "## 3.0.7 - 2014-11-14 {#version-3-0-7}"
msgstr ""

msgid "It's a minor update release."
msgstr "マイナーアップデートリリースです。"

msgid ""
"  * Fixed a bug that teardown blocks aren't called with sub class to\n"
"    parent class order.\n"
"    [GitHub#85][Reported by TOMITA Masahiro]"
msgstr ""

msgid "  * TOMITA Masahiro"
msgstr ""

msgid "## 3.0.6 - 2014-11-09 {#version-3-0-6}"
msgstr ""

msgid ""
"  * Improved code snippet location.\n"
"    [GitHub#84][Patch by Yuki Kurihara]"
msgstr ""

msgid "  * Yuki Kurihara"
msgstr ""

msgid "## 3.0.5 - 2014-11-08 {#version-3-0-5}"
msgstr ""

msgid ""
"  * Fixed a bug that startup/shutdown of parent test case isn't called\n"
"    when the test case includes one or more modules.\n"
"    [GitHub#83][Reported by Chadderton Odwazny]"
msgstr ""

msgid "  * Chadderton Odwazny"
msgstr ""

msgid "## 3.0.4 - 2014-11-01 {#version-3-0-4}"
msgstr ""

msgid ""
"  * Stopped to remove JRuby and Rubinius internal backtrace entries from\n"
"    backtrace on failure/error.\n"
"    [GitHub#82][Patch by Charles Oliver Nutter]"
msgstr ""

msgid "## 3.0.3 - 2014-10-29 {#version-3-0-3}"
msgstr ""

msgid ""
"  * Improved `Test::Unit::TestCase.test` performance.\n"
"    100 times faster.\n"
"  * Supported `Proc` for user message.\n"
"    [Sugested by Nobuyoshi Nakada]"
msgstr ""

msgid ""
"  * Fixed markup in document.\n"
"    [GitHub#81][Patch by Masafumi Yokoyama]"
msgstr ""

msgid ""
"  * Masafumi Yokoyama\n"
"  * Nobuyoshi Nakada"
msgstr ""

msgid "## 3.0.2 - 2014-10-15 {#version-3-0-2}"
msgstr ""

msgid ""
"  * Supported broken `==` implementation.\n"
"    `==` implementation should be fixed but it's not work of test-unit. :<\n"
"    [GitHub#71][Reported by Emily]\n"
"  * [UI][console]: Accepted no message failure.\n"
"    [GitHub#66][Reported by Brian Tatnall]\n"
"  * Updated gem description.\n"
"    [GitHub#74][Patch by Vít Ondruch]\n"
"  * Updated GPL text.\n"
"    [GitHub#78][Patch by Vít Ondruch]"
msgstr ""

msgid ""
"  * Removed needless executable bit from README file.\n"
"    [GitHub#79][Patch by Vít Ondruch]"
msgstr ""

msgid ""
"  * Emily\n"
"  * Brian Tatnall\n"
"  * Vít Ondruch"
msgstr ""

msgid "## 3.0.1 - 2014-08-05 {#version-3-0-1}"
msgstr ""

msgid ""
"  * Improved Ruby 1.8.7 support. Note that we don't support Ruby 1.8.7\n"
"    actively. We just support if its support is painless.\n"
"    [GitHub#71][Patch by estolfo]"
msgstr ""

msgid "  * estolfo"
msgstr ""

msgid "## 3.0.0 - 2014-08-03 {#version-3-0-0}"
msgstr ""

msgid "It's Power Assert supported release!"
msgstr "Power Assertをサポートしたリリースです！"

msgid ""
"  * Improved Rubinius support. [Ryo Onodera]\n"
"  * Updated RR repository link. [GitHub#56][Patch by Kenichi Kamiya]\n"
"  * Added some minitest compatible assertions. We don't recommend\n"
"    using these assertions. They are just for migrating from minitest.\n"
"    [GitHub#57][Patch by Karol Bucek]\n"
"    * {Test::Unit::Assertions#refute}\n"
"    * {Test::Unit::Assertions#refute_predicate}\n"
"    * {Test::Unit::Assertions#refute_empty}\n"
"    * {Test::Unit::Assertions#assert_not_includes}\n"
"    * {Test::Unit::Assertions#refute_includes}\n"
"    * {Test::Unit::Assertions#assert_not_instance_of}\n"
"    * {Test::Unit::Assertions#refute_instance_of}\n"
"    * {Test::Unit::Assertions#assert_not_kind_of}\n"
"    * {Test::Unit::Assertions#refute_kind_of}\n"
"    * {Test::Unit::Assertions#assert_not_operator}\n"
"    * {Test::Unit::Assertions#refute_operator}\n"
"  * Improved code readability. [Suggested by Kenichi Kamiya]\n"
"  * Made license field in RubyGems parseable.\n"
"    [GitHub#60][Patch by Michael Grosser]\n"
"  * Improved test case match feature by `--testcase` and `--ignore-testcase`\n"
"    options. They also checks parent class names.\n"
"  * Made inspected representation of Numeric objects especially\n"
"    BigDecimal more readable. [GitHub#64][Reported by Byron Appelt]\n"
"  * Added badges for Traivs CI and RubyGems.\n"
"    [GitHub#65][Patch by Byron Appelt]\n"
"  * Supported Power Assert. You can use Power Assert with\n"
"    {Test::Unit::Assertions#assert} with block. See method document\n"
"    for details. We recommend using Power Assert for predicate method\n"
"    checks. For example, we recommend Power Assert rather than\n"
"    {Test::Unit::Assertions#assert_true},\n"
"    {Test::Unit::Assertions#assert_predicate} and so on. We don't\n"
"    recommend using Power Assert for equality check assertion.\n"
"    {Test::Unit::Assertions#assert_equal} should be used for the case.\n"
"    [Kazuki Tsujimoto]"
msgstr ""

msgid ""
"  * Fixed a bug that test case defined by block has wrong location.\n"
"    [GitHub#58][Patch by Narihiro Nakamura]\n"
"  * Fixed a bug that test methods defined in included modules in\n"
"    super-class are also collected.\n"
"    [GitHub#62][GitHub#63][Patch by Karol Bucek]"
msgstr ""

msgid ""
"  * Ryo Onodera\n"
"  * Kenichi Kamiya\n"
"  * Karol Bucek\n"
"  * Narihiro Nakamura\n"
"  * Michael Grosser\n"
"  * Byron Appelt\n"
"  * Kazuki Tsujimoto"
msgstr ""

msgid "## 2.5.5 - 2013-05-18 {#version-2-5-5}"
msgstr ""

msgid "It's Ruby 2.0.0 supported release!"
msgstr ""

msgid ""
"  * Supported Ruby 2.0.0. [GitHub#54] [Reported by mtasaka]\n"
"  * Accepted screen-256color TERM as 256 colors available environment.\n"
"    [GitHub#55] [Reported by Tom Miller]"
msgstr ""

msgid ""
"  * Fixed a typo in document.\n"
"    [GitHub#53] [Patch by Baptiste Fontaine]\n"
"  * Fixed a bug in {Test::Unit::Assertions#assert_in_epsilon}. It doesn't work"
"\n"
"    as expected if expected value is negative value.\n"
"    [Ruby Bug #8317] [Reported by Nobuhiro IMAI]"
msgstr ""

msgid ""
"  * Baptiste Fontaine\n"
"  * mtasaka\n"
"  * Tom Miller\n"
"  * Nobuhiro IMAI"
msgstr ""

msgid "## 2.5.4 - 2013-01-23 {#version-2-5-4}"
msgstr ""

msgid ""
"  * Added documents for data driven test functionality.\n"
"  * Added TSV support for data driven test functionality.\n"
"  * Support tag inspection on JRuby."
msgstr ""

msgid ""
"  * Fixed a bug. It is too slow to filter tests when there are many\n"
"    tests. [GitHub#46]\n"
"  * Accept anonymous test suite.\n"
"    [GitHub:#49] [Reported by Matthew Rudy Jacobs]"
msgstr ""

msgid "  * Matthew Rudy Jacobs"
msgstr ""

msgid "## 2.5.3 - 2012-11-28 {#version-2-5-3}"
msgstr ""

msgid "It's a release for minitest compatibility and bug fix."
msgstr "minitestとの互換製の改良とバグフィックスのリリースです。"

msgid ""
"  * Supported diff in invalid encoding.\n"
"  * Added some assersion methods just for minitest compatibility.\n"
"    Added methods are assert_includes(), refute_*() and refute().\n"
"    If you are test-unit user, please don't use them.\n"
"    [GitHub#40] [Suggested by Michael Grosser]\n"
"  * Added --attribute option to select target tests by attribute.\n"
"    [test-unit-users-en:00098] [Suggested by Piotr Nestorow]"
msgstr ""
"  * Supported diff in invalid encoding.\n"
"  * minitestとの互換性のために、assert_includes(), refute_*() and refute()を追加た。minitestと"
"の互換性のために入れただけのメソッドなので、もしtest-unitを使っているなら、これらのメソッドははできれば使わないでください。\n"
"    [GitHub#40] [Michael Grosserさんが提案]\n"
"  * Added --attribute option to select target tests by attribute.\n"
"    [test-unit-users-en:00098] [Suggested by Piotr Nestorow]"

msgid ""
"  * Allowed use of test for inheritance in ActionController::TestCase.\n"
"    [GitHub#42] [Patch by David Rasch]\n"
"  * Ensured evaluating at_exit block in top level.\n"
"    In IRB context, exit() specifies irb_exit().\n"
"    [test-unit-users-en:00089] [Reported by Daniel Berger]\n"
"  * Fixed a bug that decoration style description is ignored.\n"
"    \"decoration style description\" are using description method\n"
"    above \"def test_name\" or with Symbol specifying test_name.\n"
"    [GitHub#45] [Reported by Piotr Nestorow]"
msgstr ""

msgid ""
"  * Michael Grosser\n"
"  * David Rasch\n"
"  * Daniel Berger\n"
"  * Piotr Nestorow"
msgstr ""

msgid "## 2.5.2 - 2012-08-29 {#version-2-5-2}"
msgstr ""

msgid ""
"It's an improvement release for tmtms. `--location` is a similar\n"
"feature to `--line_number` in RSpec. `sub_test_case` is a similar\n"
"feature to `context` in shoulda-context and RSpec."
msgstr ""
"とみたさん用に改良したリリースです。 `--location` はRSpecの `--line_number` と似た機能です。 `sub_test_cas"
"e` はshoulda-contextとRSpecの `context` と似た機能です。"

msgid ""
"  * Cleaned up tests.\n"
"    [GitHub#34] [Patch by Michael Grosser]\n"
"  * Added missing background color for 8 color environment.\n"
"  * Added workaround for NetBeans.\n"
"    [GitHub#38] [Reported by Marc Cooper]\n"
"  * Added `--location` command line option that selects target tests\n"
"    by test defined location.\n"
"  * Created sub test suite for each subclassed test case.\n"
"  * [ui][console] Supported nested test suites.\n"
"  * Added {Test::Unit.at_start} and {Test::Unit.at_exit} hooks that\n"
"    are run before/after all tests are run.\n"
"    [Good hook name is suggested by kdmsnr]\n"
"  * Improved code snippet target on failure. Test method is always used\n"
"    for code snippet target.\n"
"    [GitHub#39] [Suggested by Michael Grosser]\n"
"  * Added {Test::Unit::TestCase.sub_test_case} that creates sub test case.\n"
"    The sub test case name isn't limited Ruby's constant name rule. You can\n"
"    specify the sub test case name in free form."
msgstr ""

msgid ""
"  * Michael Grosser\n"
"  * Marc Cooper\n"
"  * kdmsnr"
msgstr ""

msgid "## 2.5.1 - 2012-07-05 {#version-2-5-1}"
msgstr ""

msgid ""
"  * Supported installing from GitHub.\n"
"    [GitHub#29] [Suggested by Michael Grosser]\n"
"  * Supported ActiveSupport::TestCase.\n"
"    [GitHub#30] [Reported by Michael Grosser]\n"
"  * [ui][console] Improved multiline falut message display."
msgstr ""

msgid ""
"  * [ui][console] Fixed a bug that expected and actual values are\n"
"    empty.\n"
"    [GitHub#31][GitHub#33]\n"
"    [Reported by Kendall Buchanan][Reported by Mathieu Martin]\n"
"    [Hinted by Michael Grosser]\n"
"  * Fixed a bug that .gemspec can't be loaded on LANG=C.\n"
"    [RubyForge#29595] [Reported by Jean-Denis Koeck]"
msgstr ""
"  * [ui][console] 期待値と実測値が空になる問題を修正。\n"
"    [GitHub#31][GitHub#33]\n"
"    [Kendall Buchananさんが報告][Mathieu Martinさんが報告]\n"
"    [Michael Grosserさんがヒントを提供]\n"
"  * Fixed a bug that .gemspec can't be loaded on LANG=C.\n"
"    [RubyForge#29595] [Reported by Jean-Denis Koeck]"

msgid ""
"  * Michael Grosser\n"
"  * Kendall Buchanan\n"
"  * Mathieu Martin\n"
"  * Jean-Denis Koeck"
msgstr ""

msgid "## 2.5.0 - 2012-06-06 {#version-2-5-0}"
msgstr ""

msgid ""
"  * Fixed a backward incompatibility of `TestUnitMediator#run_suite`\n"
"    introduced in 2.4.9.\n"
"    [GitHub#28] [Reported by Vladislav Rassokhin]"
msgstr ""
"  * 2.4.9で入った `TestUnitMediator#run_suite` の後方非互換な変更を修正しました。\n"
"    [GitHub#28] [Vladislav Rassokhinさんが報告]"

msgid "  * Vladislav Rassokhin"
msgstr "  * Vladislav Rassokhinさん"

msgid "## 2.4.9 - 2012-06-03 {#version-2-4-9}"
msgstr ""

msgid ""
"  * `Test::Unit.run?` ->\n"
"    `Test::Unit::AutoRunner.need_auto_run?`. `Test::Unit.run?` is marked\n"
"    as deprecated but it is still available.\n"
"  * [experimental] Added top level \"run\" method for `\"ruby -rtest-unit -e\n"
"    run test/test_*.rb\"`. Is this API OK or dirty?\n"
"  * Made failure output more readable on no color mode.\n"
"  * Supported showing ASCII-8BIT diff in failure message.\n"
"  * [ui][console] Supported `ENV[\"TERM\"] == \"xterm-256color\"` as color\n"
"    available terminal.\n"
"    [GitHub#26] [Reported by Michael Grosser]\n"
"  * [ui][console] Supported \"-256color\" suffix `ENV[\"TERM\"]` terminal\n"
"    as 256 color supported terminal."
msgstr ""

msgid ""
"  * Fixed a bug that `--workdir` doesn't work.\n"
"  * Consumed processed command line parameters in `ARGV` as `--help`\n"
"    says.\n"
"    [RubyForge#29554] [Reported by Bob Saveland]\n"
"  * Added missing `require \"test/unit/diff\"`.\n"
"    [GitHub#25] [Reported by Stephan Kulow]"
msgstr ""

msgid ""
"  * Bob Saveland\n"
"  * Stephan Kulow\n"
"  * Michael Grosser"
msgstr ""

msgid "## 2.4.8 - 2012-3-6 {#version-2-4-8}"
msgstr ""

msgid ""
"  * Delayed at_exit registration until Test::Unit is used.\n"
"    [GitHub:#21] [Reported by Jason Lunn]\n"
"  * Added workaround for test-spec.\n"
"    [GitHub:#22] [Reported by Cédric Boutillier]"
msgstr ""

msgid ""
"  * Fixed an error on code snippet display on JRuby.\n"
"    [GitHub:#19][GitHub:#20]\n"
"    [Reported by Jørgen P. Tjernø][Patch by Junegunn Choi]"
msgstr ""
"  * JRuby上でテスト失敗時のコード表示時に発生していたエラーを修正した。\n"
"    [GitHub:#19][GitHub:#20]\n"
"    [Jørgen P. Tjernøさんが報告][Junegunn Choiさんがパッチ提供]"

msgid ""
"  * Jørgen P. Tjernø\n"
"  * Junegunn Choi\n"
"  * Jason Lunn"
msgstr ""

msgid "## 2.4.7 - 2012-2-10 {#version-2-4-7}"
msgstr ""

msgid "It's a code snippet improvement release."
msgstr "失敗時のコード表示を改良したリリースです。"

msgid "  * Supported code snippet display on all faults."
msgstr "  * 失敗時だけでなくエラー時などでもコードの一部を表示するようにした。"

msgid "## 2.4.6 - 2012-2-9 {#version-2-4-6}"
msgstr ""

msgid "It's a TAP runner separated release."
msgstr "TAPランナーサポートを分離したリリースです。"

msgid ""
"  * Moved TAP runner to test-unit-runner-tap gem from test-unit gem.\n"
"  * Supported code snippet display on failure."
msgstr ""

msgid "## 2.4.5 - 2012-1-16 {#version-2-4-5}"
msgstr ""

msgid "It's a failure message readability improvement release."
msgstr "失敗時のメッセージの読みやすさを改良したリリースです。"

msgid ""
"  * Removed needless information from exception inspected\n"
"    text on failure. It's for easy to read.\n"
"  * Supported custom inspector."
msgstr ""
"  * 失敗時に例外の内容を示すテキストから不必要な情報を削除した。これは例外の内容を読みやすくするためである。\n"
"  * Supported custom inspector."

msgid "## 2.4.4 - 2012-1-2 {#version-2-4-4}"
msgstr ""

msgid "It's a Rails integration improved release."
msgstr "Railsと一緒に使いやすくなったリリースです。"

msgid ""
"  * [ui][console] Don't break progress display when a test is failed.\n"
"  * [ui][console] Added markers betwen a failure detail\n"
"    message in progress to improve visibility.\n"
"  * [travis] Dropped Ruby 1.8.6 as a test target. [GitHub:#13]\n"
"    [Patch by Josh Kalderimis]\n"
"  * Supported expected value == 0 case in assert_in_epsilon. [RubyForge#29485]"
"\n"
"    [Reported by Syver Enstad]\n"
"  * Supported a block style setup/teardown/cleanup."
msgstr ""

msgid ""
"  * Josh Kalderimis\n"
"  * Syver Enstad"
msgstr ""

msgid "## 2.4.3 - 2011-12-11 {#version-2-4-3}"
msgstr ""

msgid ""
"  * Improved SimpleCov integration by stopping to modify\n"
"    `ARGV` in auto runner. [GitHub:#12]\n"
"    [Reported by Nikos Dimitrakopoulos]\n"
"  * Improved JRuby integration by removing JRuby internal backtrace."
msgstr ""
"  * 自動テストランナー内で `ARGV` を変更しないようにしてSimpleCov連携を改良した。\n"
"    [GitHub:#12]\n"
"    [Nikos Dimitrakopoulosさんが報告]\n"
"  * Improved JRuby integration by removing JRuby internal backtrace."

msgid "  * Nikos Dimitrakopoulos"
msgstr "  * Nikos Dimitrakopoulosさん"

msgid "## 2.4.2 - 2011-11-26 {#version-2-4-2}"
msgstr ""

msgid "  * `--name` supported data label."
msgstr "  * `--name` がデータのラベルも比較するようになった。"

msgid "## 2.4.1 - 2011-11-09"
msgstr ""

msgid ""
"  * Accepted AssertionMessage as assertion's user message.\n"
"    It is used in assert_select in actionpack.\n"
"    [Reported by David Heath]"
msgstr ""
"  * アサーションに指定するメッセージにAssertionMessageも使えるようにした。これはactionpack内のassert_selectで使わ"
"れている。\n"
"    [David Heathさんが報告]"

msgid ""
"  * Fixed test failure on LANG=C. #11 [Reported by boutil]\n"
"  * Suppress warnings on Ruby 1.9.2."
msgstr ""

msgid ""
"  * boutil\n"
"  * David Heath"
msgstr ""

msgid "## 2.4.0 - 2011-09-18"
msgstr ""

msgid ""
"  * Supported Travis CI. #5 [Suggested by James Mead]\n"
"  * Added Gemfile. #6 [Suggested by James Mead]\n"
"  * [ui][console] Supported notification in show-detail-immediately.\n"
"  * [ui][console] enable --show-detail-immediately by default.\n"
"  * [ui] Added --max-diff-target-string-size option.\n"
"  * [ui][console] Supported 256 colors."
msgstr ""

msgid ""
"  * Added missing fixture file. #7 [Reported by grafi-tt]\n"
"  * [ui][console] Added missing the last newline for progress level.\n"
"  * Supported correct backtrace for redefined notification.\n"
"  * Don't handle Timeout::Error as pass through exception on Ruby 1.8. #8\n"
"    [Reported by Marc Seeger (Acquia)]"
msgstr ""

msgid ""
"  * James Mead\n"
"  * grafi-tt\n"
"  * Marc Seeger (Acquia)"
msgstr ""

msgid "## 2.3.2 - 2011-08-15"
msgstr ""

msgid "A bug fix release."
msgstr "バグフィックスリリース。"

msgid "  * [ui][console] Added some newlines to improve readability."
msgstr "  * [ui][console] 読み易くするために改行を追加。"

msgid ""
"  * [ui][console] Worked --verbose again.\n"
"  * Re-supported Ruby 1.8.6. [Reported by James Mead]"
msgstr ""
"  * [ui][console] Worked --verbose again.\n"
"  * Ruby 1.8.6を再サポート。\n"
"    [James Meadさんが報告]"

msgid "  * James Mead"
msgstr "  * James Meadさん"

msgid "## 2.3.1 - 2011-08-06 {#version-2-3-1}"
msgstr ""

msgid "Output improvement release!"
msgstr ""

msgid ""
"  * [ui][console] Outputs omissions and notifications in short.\n"
"  * [ui][console] Added \"important-only\" verbose level.\n"
"  * Intelligence diff supports recursive references.\n"
"  * [rubyforge #29325] Supported Ruby Enterprise Edition.\n"
"    [Reported by Hans de Graaff]\n"
"  * [rubyforge #29326] Supported JRuby.\n"
"    [Reported by Hans de Graaff]\n"
"  * Added --show-detail-immediately option that shows\n"
"    fault details when a fault is occurred."
msgstr ""

msgid ""
"  * [pull request #1] Fixed a problem that load collector\n"
"    can't load a test file on Ruby 1.9. [Patch by grafi-tt]\n"
"  * [issue #3] Fixed a problem that implicit method name\n"
"    override by declarative style test definition.\n"
"    [Reported by Jeremy Stephens]"
msgstr ""

msgid ""
"  * grafi-tt\n"
"  * Jeremy Stephens\n"
"  * Hans de Graaff"
msgstr ""

msgid "## 2.3.0 / 2011-04-17"
msgstr ""

msgid ""
"* 13 enhancements\n"
"  * improve Hash key sorting for diff.\n"
"  * [#28928] support any characters in declarative style description.\n"
"    [Daniel Berger]\n"
"  * add Error#location and make #backtrace deprecated.\n"
"  * make TestCase#passed? public.\n"
"  * add result finished and pass assertion notifications.\n"
"  * add TestSuite#passed? public.\n"
"  * add XML test runner.\n"
"  * add --output-file-descriptor option.\n"
"  * measure elapsed time for each test.\n"
"  * add --collector option.\n"
"  * support test driven test.\n"
"    [Haruka Yoshihara]\n"
"  * add cleanup hook it runs between after test and before teardown.\n"
"  * support recursive collection sort for diff."
msgstr ""

msgid ""
"* Thanks\n"
"  * Daniel Berger\n"
"  * Haruka Yoshihara"
msgstr ""

msgid "## 2.2.0 / 2011-02-14"
msgstr ""

msgid ""
"* 22 enhancements\n"
"  * [#28808] accept String as delta for assert_in_delta.\n"
"    [Daniel Berger]\n"
"  * [test-unit-users-en:00035] make GC-able finished tests.\n"
"    [Daniel Berger]\n"
"  * use also COLUMNS environment variable to guess terminal width.\n"
"  * make delta for assert_in_delta optional.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_respond_to.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_match. assert_no_match is deprecated.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_in_delta.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_in_epsilon.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_in_epsilon.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_include.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_include.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_empty.\n"
"    [Nobuyoshi Nakada]\n"
"  * add assert_not_empty.\n"
"    [Nobuyoshi Nakada]\n"
"  * notify require failed paths.\n"
"  * validate message value for assert.\n"
"  * show throughputs at the last.\n"
"  * support not ASCII compatible string diff.\n"
"  * support colorized diff on encoding different string.\n"
"  * normalize entry order of Hash for readable diff.\n"
"  * add --ignore-name option.\n"
"  * add --ignore-testcase option.\n"
"  * add assert_not_send."
msgstr ""

msgid ""
"* Thanks\n"
"  * Daniel Berger\n"
"  * Nobuyoshi Nakada"
msgstr ""

msgid "## 2.1.2 / 2010-11-25"
msgstr ""

msgid ""
"* 1 enhancement\n"
"  * support auto runner prepare hook."
msgstr ""

msgid "## 2.1.1 / 2010-07-29"
msgstr ""

msgid ""
"* 1 bug fix\n"
"  * [test-unit-users-en:00026] re-work tap runner.\n"
"    [Daniel Berger]"
msgstr ""

msgid ""
"* Thanks\n"
"  * Daniel Berger"
msgstr ""

msgid "=== 2.1.0 / 2010-07-17"
msgstr ""

msgid ""
"* 1 bug fix\n"
"  * [#28267] global config file ignored\n"
"    [Daniel Berger]"
msgstr ""

msgid "## 2.0.8 / 2010-06-02"
msgstr ""

msgid ""
"* 5 major enchancements\n"
"  * collect *_test.rb and *-test.rb files as test files.\n"
"  * [#28181] improve assert_in_delta message.\n"
"    [Suggested by David MARCHALAND]\n"
"  * show string encoding in assert_equal failure message if\n"
"    they are different.\n"
"  * change default color scheme:\n"
"    * success: green back + white\n"
"    * failure: red back + white\n"
"  * add capture_output."
msgstr ""

msgid ""
"* 2 bug fixes\n"
"  * fix a bug that console runner on verbose mode causes an\n"
"    error for long test name (>= 61).\n"
"  * [#28093] Autorunner ignores all files in a directory named test by default"
"\n"
"    [Reported by Florian Frank]"
msgstr ""

msgid ""
"* Thanks\n"
"  * Florian Frank\n"
"  * David MARCHALAND"
msgstr ""

msgid "## 2.0.7 / 2010-03-09"
msgstr ""

msgid ""
"* 4 major enhancements\n"
"  * detect redefined test methods.\n"
"  * [INTERFACE IMCOMPATIBLE] multiple --name and --testcase\n"
"    options narrow down targets instead of adding targets.\n"
"  * [#27764] accept custom test_order for each test case.\n"
"    [Suggested by David MARCHALAND]\n"
"  * [#27790] ignore omitted tests from 'n% passed' report.\n"
"    [Suggested by Daniel Berger]"
msgstr ""

msgid ""
"* 2 minor enchancements\n"
"  * [#27832] ignore .git directory. [Suggested by Daniel Berger]\n"
"  * [#27792] require 'fileutils' and 'tmpdir' lazily for non-priority\n"
"    mode users. [Suggested by David MARCHALAND]"
msgstr ""

msgid ""
"* 2 bug fixes\n"
"  * [#27892] modify processed arguments array destructively.\n"
"    [Reported by Bob Saveland]\n"
"  * work without HOME environment variable.\n"
"    [Reported by Champak Ch]"
msgstr ""

msgid ""
"* Thanks\n"
"  * David MARCHALAND\n"
"  * Daniel Berger\n"
"  * Bob Saveland\n"
"  * Champak Ch"
msgstr ""

msgid "## 2.0.6 / 2010-01-09"
msgstr ""

msgid ""
"* 3 major enhancements\n"
"  * [#27380] Declarative syntax? [Daniel Berger]\n"
"    support declarative syntax:"
msgstr ""

msgid ""
"      test \"test description in natural language\" do\n"
"         ...\n"
"      end\n"
"  * support test description:\n"
"      description \"test description in natural language\"\n"
"      def test_my_test\n"
"         ...\n"
"      end\n"
"  * make max diff target string size customizable by\n"
"    TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE environment variable."
msgstr ""

msgid ""
"* 2 bug fixes\n"
"  * [#27374] omit_if unexpected behavior [David MARCHALAND]\n"
"  * fix a bug that tests in sub directories aren't load with --basedir.\n"
"    [Daniel Berger]"
msgstr ""

msgid ""
"* Thanks\n"
"  * David MARCHALAND\n"
"  * Daniel Berger"
msgstr ""

msgid "## 2.0.5 / 2009-10-18"
msgstr ""

msgid ""
"* 1 bug fixes\n"
"  * [#27314] fix diff may raise an exception. [Erik Hollensbe]"
msgstr ""

msgid ""
"* Thanks\n"
"  * Erik Hollensbe"
msgstr ""

msgid "## 2.0.4 / 2009-10-17"
msgstr ""

msgid ""
"* 4 major enhancements\n"
"  * use ~/.test-unit.yml as global configuration file.\n"
"  * add TAP runner. (--runner tap)\n"
"  * support colorized diff:\n"
"    https://test-unit.github.io/color-diff.png\n"
"  * add Test::Unit::AutoRunner.default_runner= to specify default test runner."
msgstr ""

msgid ""
"* 4 minor enhancements\n"
"  * improve verbose mode output format. (use indent)\n"
"  * support `NOT_PASS_THROUGH_EXCEPTIONS`.\n"
"  * support arguments option in `#{runner}_options`.\n"
"  * TC_ -> Test in sample test case name."
msgstr ""

msgid ""
"* 1 bug fixes\n"
"  * [#27195] test-unit-2.0.3 + ruby-1.9.1 cannot properly test\n"
"    DelegateClass subclasses [Mike Pomraning]"
msgstr ""

msgid ""
"* Thanks\n"
"  * Mike Pomraning"
msgstr ""

msgid "## 2.0.3 / 2009-07-19"
msgstr ""

msgid ""
"* 6 major enhancements\n"
"  * add assert_predicate.\n"
"  * add assert_not_predicate.\n"
"  * [#24210] assert_kind_of supports an array of classes or modules.\n"
"    [Daniel Berger]\n"
"  * assert_instance_of supports an array of classes or modules.\n"
"  * add --default-priority option.\n"
"  * [#26627] add --order option. [Daniel Berger]"
msgstr ""

msgid ""
"* 4 minor enhancements\n"
"  * use yellow foreground + black background for error.\n"
"  * don't show diff for long string.\n"
"  * accept \"*term-color\" TERM environment as colorizable terminal.\n"
"    (e.g. Apple's Terminal)\n"
"  * [#26268] add a workaround for test-spec's after_all. [Angelo Lakra]"
msgstr ""

msgid ""
"* 1 bug fix\n"
"  * [#23586] re-support ruby 1.9.1. [Diego Pettenò]"
msgstr ""

msgid ""
"* Thanks\n"
"  * Diego Pettenò\n"
"  * Daniel Berger\n"
"  * Angelo Lakra"
msgstr ""

msgid "## 2.0.2 / 2008-12-21"
msgstr ""

msgid "* 2 major enhancements"
msgstr ""

msgid ""
"  * re-support ruby 1.8.5.\n"
"  * improve exception object comparison."
msgstr ""

msgid "* 3 bug fixes"
msgstr ""

msgid ""
"  * [#22723]: collector fails on anonymous classes\n"
"  * [#22986]: Test names with '?' blow up on Windows\n"
"  * [#22988]: don't create .test-result on non-priority mode."
msgstr ""

msgid "* Thanks"
msgstr "* 感謝"

msgid ""
"  * Erik Hollensbe\n"
"  * Daniel Berger\n"
"  * Bill Lear"
msgstr ""

msgid "## 2.0.1 / 2008-11-09"
msgstr ""

msgid "* 19 major enhancements"
msgstr ""

msgid ""
"  * support ruby 1.9.1.\n"
"  * add run_test method to be extensible.\n"
"  * improve priority-mode auto off.\n"
"  * improve startup/shutdown RDoc. [Daniel Berger]\n"
"  * add assert_compare. [#20851] [Designing Patterns]\n"
"  * add assert_fail_assertion. [#20851] [Designing Patterns]\n"
"  * add assert_raise_message. [#20851] [Designing Patterns]\n"
"  * support folded diff.\n"
"  * add assert_raise_kind_of. [Daniel Berger]\n"
"  * ingore inherited test for nested test case.\n"
"  * add assert_const_defined.\n"
"  * add assert_not_const_defined.\n"
"  * support assert_raise with an exception object.\n"
"  * support assert_raise with no arguments that asserts any\n"
"    exception is raised. [#22602] [Daniel Berger]\n"
"  * support folded dot progress.\n"
"  * add --progress-row-max option.\n"
"  * support color scheme customize.\n"
"  * support configuration file. (YAML)\n"
"  * recognize test-XXX.rb files as test files not only test_XXX.rb"
msgstr ""

msgid ""
"  * Daniel Berger\n"
"  * Designing Patterns"
msgstr ""

msgid "## 2.0.0 / 2008-06-18"
msgstr ""

msgid "* 15 major enhancements"
msgstr ""

msgid ""
"  * support startup/shutdown. (test case level setup/teardown)\n"
"  * support multiple setup/teardown.\n"
"  * support pending.\n"
"  * support omission.\n"
"  * support notification.\n"
"  * support colorize.\n"
"  * support diff.\n"
"  * support test attribute.\n"
"  * add assert_boolean.\n"
"  * add assert_true.\n"
"  * add assert_false.\n"
"  * add --priority-mode option.\n"
"  * don't use ObjectSpace to collect test cases.\n"
"  * make more customizable. (additional options, exception handling and so on)"
"\n"
"  * improve Emacs integration."
msgstr ""

msgid "* 4 major changes"
msgstr ""

msgid ""
"  * remove GTK+1 support.\n"
"  * split GTK+ runner as another gem.\n"
"  * split FOX runner as another gem.\n"
"  * split Tk runner as another gem."
msgstr ""

msgid "## 1.2.3 / 2008-02-25"
msgstr ""

msgid "* 1 major enhancement"
msgstr ""

msgid "  * Birthday (as a gem)!"
msgstr ""

msgid ":nodoc:"
msgstr ""

# Test::Unit
msgid "# Test::Unit - Ruby Unit Testing Framework"
msgstr ""

# Test::Unit
msgid "## Introduction"
msgstr ""

# Test::Unit
msgid ""
"Unit testing is making waves all over the place, largely due to the\n"
"fact that it is a core practice of XP. While XP is great, unit testing\n"
"has been around for a long time and has always been a good idea. One\n"
"of the keys to good unit testing, though, is not just writing tests,\n"
"but having tests. What's the difference? Well, if you just _write_ a\n"
"test and throw it away, you have no guarantee that something won't\n"
"change later which breaks your code. If, on the other hand, you _have_\n"
"tests (obviously you have to write them first), and run them as often\n"
"as possible, you slowly build up a wall of things that cannot break\n"
"without you immediately knowing about it. This is when unit testing\n"
"hits its peak usefulness."
msgstr ""

# Test::Unit
msgid ""
"Enter Test::Unit, a framework for unit testing in Ruby, helping you to\n"
"design, debug and evaluate your code by making it easy to write and\n"
"have tests for it."
msgstr ""

# Test::Unit
msgid "## Notes"
msgstr ""

msgid "Test::Unit has grown out of and superceded Lapidary."
msgstr ""

# #run_test
msgid ""
"experimental. It is for \"ruby -rtest-unit -e run_test test/test_*.rb\".\n"
"Is this API OK or dirty?"
msgstr ""

# Test::Unit
msgid "## Feedback"
msgstr ""

# Test::Unit
msgid ""
"I like (and do my best to practice) XP, so I value early releases,\n"
"user feedback, and clean, simple, expressive code. There is always\n"
"room for improvement in everything I do, and Test::Unit is no\n"
"exception. Please, let me know what you think of Test::Unit as it\n"
"stands, and what you'd like to see expanded/changed/improved/etc. If\n"
"you find a bug, let me know ASAP; one good way to let me know what the\n"
"bug is is to submit a new test that catches it :-) Also, I'd love to\n"
"hear about any successes you have with Test::Unit, and any\n"
"documentation you might add will be greatly appreciated. My contact\n"
"info is below."
msgstr ""

# Test::Unit
msgid "## Contact Information"
msgstr ""

# Test::Unit
msgid ""
"A lot of discussion happens about Ruby in general on the ruby-talk\n"
"mailing list (http://www.ruby-lang.org/en/ml.html), and you can ask\n"
"any questions you might have there. I monitor the list, as do many\n"
"other helpful Rubyists, and you're sure to get a quick answer. Of\n"
"course, you're also welcome to email me (Nathaniel Talbott) directly\n"
"at mailto:testunit@talbott.ws, and I'll do my best to help you out."
msgstr ""

# Test::Unit
msgid "## Credits"
msgstr ""

msgid "I'd like to thank..."
msgstr ""

msgid "Matz, for a great language!"
msgstr ""

# Test::Unit
msgid ""
"Masaki Suketa, for his work on RubyUnit, which filled a vital need in\n"
"the Ruby world for a very long time. I'm also grateful for his help in\n"
"polishing Test::Unit and getting the RubyUnit compatibility layer\n"
"right. His graciousness in allowing Test::Unit to supercede RubyUnit\n"
"continues to be a challenge to me to be more willing to defer my own\n"
"rights."
msgstr ""

# Test::Unit
msgid ""
"Ken McKinlay, for his interest and work on unit testing, and for his\n"
"willingness to dialog about it. He was also a great help in pointing\n"
"out some of the holes in the RubyUnit compatibility layer."
msgstr ""

# Test::Unit
msgid ""
"Dave Thomas, for the original idea that led to the extremely simple\n"
"\"require 'test/unit'\", plus his code to improve it even more by\n"
"allowing the selection of tests from the command-line. Also, without\n"
"RDoc, the documentation for Test::Unit would stink a lot more than it\n"
"does now."
msgstr ""

# Test::Unit
msgid ""
"Everyone who's helped out with bug reports, feature ideas,\n"
"encouragement to continue, etc. It's a real privilege to be a part of\n"
"the Ruby community."
msgstr ""

# Test::Unit
msgid ""
"The guys at RoleModel Software, for putting up with me repeating, \"But\n"
"this would be so much easier in Ruby!\" whenever we're coding in Java."
msgstr ""

msgid "My Creator, for giving me life, and giving it more abundantly."
msgstr ""

# Test::Unit
msgid ""
"Test::Unit is copyright (c) 2000-2003 Nathaniel Talbott. It is free\n"
"software, and is distributed under the Ruby license. See the COPYING\n"
"file."
msgstr ""

# Test::Unit
msgid ""
"Exception: lib/test/unit/diff.rb is copyright (c)\n"
"2008-2010 Kouhei Sutou and 2001-2008 Python Software\n"
"Foundation. It is free software, and is distributed\n"
"under the Ruby license and/or the PSF license. See the\n"
"COPYING file and PSFL file."
msgstr ""

# Test::Unit
msgid "## Warranty"
msgstr ""

# Test::Unit
msgid ""
"This software is provided \"as is\" and without any express or\n"
"implied warranties, including, without limitation, the implied\n"
"warranties of merchantibility and fitness for a particular\n"
"purpose."
msgstr ""

# Test::Unit
msgid "## Author"
msgstr ""

# Test::Unit
msgid ""
"Nathaniel Talbott.\n"
"Copyright (c) 2000-2003, Nathaniel Talbott"
msgstr ""

# Test::Unit
msgid "----"
msgstr ""

# Test::Unit
msgid "# Usage"
msgstr ""

# Test::Unit
msgid ""
"The general idea behind unit testing is that you write a _test_\n"
"_method_ that makes certain _assertions_ about your code, working\n"
"against a _test_ _fixture_. A bunch of these _test_ _methods_ are\n"
"bundled up into a _test_ _suite_ and can be run any time the\n"
"developer wants. The results of a run are gathered in a _test_\n"
"_result_ and displayed to the user through some UI. So, lets break\n"
"this down and see how Test::Unit provides each of these necessary\n"
"pieces."
msgstr ""

# Test::Unit
msgid "## Assertions"
msgstr ""

# Test::Unit
msgid ""
"These are the heart of the framework. Think of an assertion as a\n"
"statement of expected outcome, i.e. \"I assert that x should be equal\n"
"to y\". If, when the assertion is executed, it turns out to be\n"
"correct, nothing happens, and life is good. If, on the other hand,\n"
"your assertion turns out to be false, an error is propagated with\n"
"pertinent information so that you can go back and make your\n"
"assertion succeed, and, once again, life is good. For an explanation\n"
"of the current assertions, see Test::Unit::Assertions."
msgstr ""

# Test::Unit
msgid "## Test Method & Test Fixture"
msgstr ""

# Test::Unit
msgid ""
"Obviously, these assertions have to be called within a context that\n"
"knows about them and can do something meaningful with their\n"
"pass/fail value. Also, it's handy to collect a bunch of related\n"
"tests, each test represented by a method, into a common test class\n"
"that knows how to run them. The tests will be in a separate class\n"
"from the code they're testing for a couple of reasons. First of all,\n"
"it allows your code to stay uncluttered with test code, making it\n"
"easier to maintain. Second, it allows the tests to be stripped out\n"
"for deployment, since they're really there for you, the developer,\n"
"and your users don't need them. Third, and most importantly, it\n"
"allows you to set up a common test fixture for your tests to run\n"
"against."
msgstr ""

# Test::Unit
msgid ""
"What's a test fixture? Well, tests do not live in a vacuum; rather,\n"
"they're run against the code they are testing. Often, a collection\n"
"of tests will run against a common set of data, also called a\n"
"fixture. If they're all bundled into the same test class, they can\n"
"all share the setting up and tearing down of that data, eliminating\n"
"unnecessary duplication and making it much easier to add related\n"
"tests."
msgstr ""

# Test::Unit
msgid ""
"Test::Unit::TestCase wraps up a collection of test methods together\n"
"and allows you to easily set up and tear down the same test fixture\n"
"for each test. This is done by overriding #setup and/or #teardown,\n"
"which will be called before and after each test method that is\n"
"run. The TestCase also knows how to collect the results of your\n"
"assertions into a Test::Unit::TestResult, which can then be reported\n"
"back to you... but I'm getting ahead of myself. To write a test,\n"
"follow these steps:"
msgstr ""

# Test::Unit
msgid ""
"* Make sure Test::Unit is in your library path.\n"
"* require 'test/unit' in your test script.\n"
"* Create a class that subclasses Test::Unit::TestCase.\n"
"* Add a method that begins with \"test\" to your class.\n"
"* Make assertions in your test method.\n"
"* Optionally define #setup and/or #teardown to set up and/or tear\n"
"  down your common test fixture.\n"
"* You can now run your test as you would any other Ruby\n"
"  script... try it and see!"
msgstr ""

# Test::Unit
msgid ""
"A really simple test might look like this (#setup and #teardown are\n"
"commented out to indicate that they are completely optional):"
msgstr ""

# Test::Unit
msgid ""
"    class MyTest < Test::Unit::TestCase\n"
"      # def setup\n"
"      # end"
msgstr ""

# Test::Unit
msgid ""
"      # def teardown\n"
"      # end"
msgstr ""

# Test::Unit
msgid ""
"      def test_fail\n"
"        assert(false, 'Assertion was false.')\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit
msgid "## Test Runners"
msgstr ""

# Test::Unit
msgid ""
"So, now you have this great test class, but you still\n"
"need a way to run it and view any failures that occur\n"
"during the run. There are some test runner; console test\n"
"runner, GTK+ test runner and so on. The console test\n"
"runner is automatically invoked for you if you require\n"
"'test/unit' and simply run the file. To use another\n"
"runner simply set default test runner ID to\n"
"Test::Unit::AutoRunner:"
msgstr ""

# Test::Unit
msgid ""
"    require 'test/unit'\n"
"    Test::Unit::AutoRunner.default_runner = \"gtk2\""
msgstr ""

# Test::Unit
msgid "## Test Suite"
msgstr ""

# Test::Unit
msgid ""
"As more and more unit tests accumulate for a given project, it\n"
"becomes a real drag running them one at a time, and it also\n"
"introduces the potential to overlook a failing test because you\n"
"forget to run it. Suddenly it becomes very handy that the\n"
"TestRunners can take any object that returns a Test::Unit::TestSuite\n"
"in response to a suite method. The TestSuite can, in turn, contain\n"
"other TestSuites or individual tests (typically created by a\n"
"TestCase). In other words, you can easily wrap up a group of\n"
"TestCases and TestSuites."
msgstr ""

# Test::Unit
msgid ""
"Test::Unit does a little bit more for you, by wrapping\n"
"these up automatically when you require\n"
"'test/unit'. What does this mean? It means you could\n"
"write the above test case like this instead:"
msgstr ""

# Test::Unit
msgid ""
"    require 'test/unit'\n"
"    require 'test_myfirsttests'\n"
"    require 'test_moretestsbyme'\n"
"    require 'test_anothersetoftests'"
msgstr ""

# Test::Unit
msgid ""
"Test::Unit is smart enough to find all the test cases existing in\n"
"the ObjectSpace and wrap them up into a suite for you. It then runs\n"
"the dynamic suite using the console TestRunner."
msgstr ""

# Test::Unit
msgid "## Configuration file"
msgstr ""

msgid ""
"Test::Unit reads 'test-unit.yml' in the current working\n"
"directory as Test::Unit's configuration file. It can\n"
"contain the following configurations:"
msgstr ""
"Test::Unitは現在のワーキングディレクトリにある'test-unit.yml'をTest::Unitの設定ファイルとして読み込みます。このファイルに"
"は以下のような設定をすることができます。"

msgid ""
"Except color scheme definitions, all of them are\n"
"specified by command line option."
msgstr "カラースキーム定義以外はコマンドラインオプションで指定することができます。"

# Test::Unit
msgid ""
"SCHEME_NAME\n"
": the name of the color scheme"
msgstr ""

# Test::Unit
msgid ""
"EVENT_NAME\n"
": one of [success, failure, pending, omission, notification, error]"
msgstr ""

# Test::Unit
msgid ""
"COLOR_NAME\n"
": one of [black, red, green, yellow, blue, magenta, cyan, white]"
msgstr ""

# Test::Unit
msgid ""
"BOOLEAN\n"
": true or false"
msgstr ""

msgid ""
"You can use the above 'inverted' color scheme with the\n"
"following configuration:"
msgstr "上で定義した'inverted'カラースキムを使う設定は以下の通りです。"

# Test::Unit
msgid "## Questions?"
msgstr ""

# Test::Unit
msgid ""
"I'd really like to get feedback from all levels of Ruby\n"
"practitioners about typos, grammatical errors, unclear statements,\n"
"missing points, etc., in this document (or any other)."
msgstr ""

# @deprecated
msgid "Use Test::Unit::AutoRunner.need_auto_run= instead."
msgstr ""

# Test::Unit.run=
msgid ""
"Set true when Test::Unit has run.  If set to true Test::Unit\n"
"will not automatically run at exit."
msgstr ""

# @deprecated
msgid "Use Test::Unit::AutoRunner.need_auto_run? instead."
msgstr ""

# Test::Unit.run?
msgid "Already tests have run?"
msgstr ""

msgid "private"
msgstr ""

# Test::Unit.at_start
msgid ""
"Register a hook that is run before running tests.\n"
"To register multiple hooks, call this method multiple times."
msgstr ""

# Test::Unit.at_exit
# Test::Unit.at_start
# Test::Unit::TestCase.shutdown
# Test::Unit::TestCase.startup
msgid "Here is an example test case:"
msgstr ""

# Test::Unit.at_start
msgid ""
"    Test::Unit.at_start do\n"
"      # ...\n"
"    end"
msgstr ""

# Test::Unit.at_start
msgid ""
"    class TestMyClass1 < Test::Unit::TestCase\n"
"      class << self\n"
"        def startup\n"
"          # ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit.at_start
msgid ""
"      def setup\n"
"        # ...\n"
"      end"
msgstr ""

# Test::Unit.at_exit
# Test::Unit.at_start
msgid ""
"      def test_my_class1\n"
"        # ...\n"
"      end"
msgstr ""

# Test::Unit.at_exit
# Test::Unit.at_start
msgid ""
"      def test_my_class2\n"
"        # ...\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit.at_start
msgid ""
"    class TestMyClass2 < Test::Unit::TestCase\n"
"      class << self\n"
"        def startup\n"
"          # ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid "Here is a call order:"
msgstr ""

# Test::Unit.at_start
msgid ""
"* at_start\n"
"* TestMyClass1.startup\n"
"* TestMyClass1#setup\n"
"* TestMyClass1#test_my_class1\n"
"* TestMyClass1#setup\n"
"* TestMyClass1#test_my_class2\n"
"* TestMyClass2#setup\n"
"* TestMyClass2#test_my_class1\n"
"* TestMyClass2#setup\n"
"* TestMyClass2#test_my_class2"
msgstr ""

# @example
msgid ""
"Test::Unit.at_start do\n"
"  puts \"Start!\"\n"
"end"
msgstr ""

# @since
msgid "2.5.2"
msgstr ""

# @yield
msgid "A block that is run before running tests."
msgstr ""

# Test::Unit.at_exit
msgid ""
"Register a hook that is run after running tests.\n"
"To register multiple hooks, call this method multiple times."
msgstr ""

# Test::Unit.at_exit
msgid ""
"    Test::Unit.at_exit do\n"
"      # ...\n"
"    end"
msgstr ""

# Test::Unit.at_exit
msgid ""
"    class TestMyClass1 < Test::Unit::TestCase\n"
"      class << self\n"
"        def shutdown\n"
"          # ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit.at_exit
msgid ""
"      def teardown\n"
"        # ...\n"
"      end"
msgstr ""

# Test::Unit.at_exit
msgid ""
"    class TestMyClass2 < Test::Unit::TestCase\n"
"      class << self\n"
"        def shutdown\n"
"          # ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit.at_exit
msgid ""
"* TestMyClass1#test_my_class1\n"
"* TestMyClass1#teardown\n"
"* TestMyClass1#test_my_class2\n"
"* TestMyClass1#teardown\n"
"* TestMyClass1.shutdown\n"
"* TestMyClass2#test_my_class1\n"
"* TestMyClass2#teardown\n"
"* TestMyClass2#test_my_class2\n"
"* TestMyClass2#teardown\n"
"* TestMyClass2.shutdown\n"
"* at_exit"
msgstr ""

# @example
msgid ""
"Test::Unit.at_exit do\n"
"  puts \"Exit!\"\n"
"end"
msgstr ""

# @yield
msgid "A block that is run after running tests."
msgstr ""

msgid "Thrown by Test::Unit::Assertions when an assertion fails."
msgstr ""

# @param
msgid "tag|param|value"
msgstr ""

# @param value
msgid "the value to set the attribute expected to."
msgstr ""

# @param value
msgid "the value to set the attribute actual to."
msgstr ""

# @param value
msgid "the value to set the attribute user_message to."
msgstr ""

msgid "Returns the value of attribute expected"
msgstr ""

# Test::Unit::AssertionFailedError#expected=
msgid "Sets the attribute expected"
msgstr ""

msgid "Returns the value of attribute actual"
msgstr ""

# Test::Unit::AssertionFailedError#actual=
msgid "Sets the attribute actual"
msgstr ""

msgid "Returns the value of attribute user_message"
msgstr ""

# Test::Unit::AssertionFailedError#user_message=
msgid "Sets the attribute user_message"
msgstr ""

# @param value
msgid "the value to set the attribute inspected_expected to."
msgstr ""

# @param value
msgid "the value to set the attribute inspected_actual to."
msgstr ""

msgid "Returns the value of attribute inspected_expected"
msgstr ""

# Test::Unit::AssertionFailedError#inspected_expected=
msgid "Sets the attribute inspected_expected"
msgstr ""

msgid "Returns the value of attribute inspected_actual"
msgstr ""

# Test::Unit::AssertionFailedError#inspected_actual=
msgid "Sets the attribute inspected_actual"
msgstr ""

# @return [AssertionFailedError]
msgid "a new instance of AssertionFailedError"
msgstr ""

# Test::Unit::Assertions
msgid ""
"Test::Unit::Assertions contains the standard Test::Unit assertions.\n"
"Assertions is included in Test::Unit::TestCase."
msgstr ""

# Test::Unit::Assertions
msgid ""
"To include it in your own code and use its functionality, you simply\n"
"need to rescue Test::Unit::AssertionFailedError. Additionally you may\n"
"override add_assertion to get notified whenever an assertion is made."
msgstr ""

# Test::Unit::Assertions
msgid "Notes:"
msgstr ""

# Test::Unit::Assertions
msgid ""
"* The message to each assertion, if given, will be propagated with the\n"
"  failure.\n"
"* It is easy to add your own assertions based on assert_block()."
msgstr ""

# @example
msgid "tag|example|Example Custom Assertion"
msgstr ""

# @example Example Custom Assertion
msgid ""
"\n"
"def deny(boolean, message=nil)\n"
"  message = build_message(message, ' is not false or nil.', boolean)\n"
"  assert_block(message) do\n"
"    not boolean\n"
"  end\n"
"end"
msgstr ""

# Test::Unit::Assertions#assert_block
msgid ""
"The assertion upon which all other assertions are based. Passes if the\n"
"block yields true."
msgstr ""

# @example
msgid ""
"assert_block \"Couldn't do the thing\" do\n"
"  do_the_thing\n"
"end"
msgstr ""

# @overload
msgid "tag|overload|assert"
msgstr ""

# @example
msgid "tag|example|Pass patterns"
msgstr ""

# @example Pass patterns
msgid ""
"assert(true)               # => pass\n"
"assert([1, 2].include?(1)) # => pass"
msgstr ""

# @example
msgid "tag|example|Failure patterns"
msgstr ""

# @example Failure patterns
msgid ""
"assert(nil)                # => failure\n"
"assert(false)              # => failure\n"
"assert([1, 2].include?(5)) # => failure"
msgstr ""

# @param [Object]
msgid "tag|param|object"
msgstr ""

# @param [Object] object
msgid "The check target."
msgstr ""

# @param [String]
msgid "tag|param|message"
msgstr ""

# @param [String] message
msgid ""
"The additional user message. It is\n"
"showed when the assertion is failed."
msgstr ""

# @example
msgid "tag|example|Power Assert"
msgstr ""

# @example Power Assert
msgid ""
"coins = [1, 5, 50]\n"
"target_coin = 10\n"
"assert do\n"
"  coins.include?(target_coin)\n"
"end\n"
"# =>\n"
"#  coins.include?(target_coin)\n"
"#  |     |        |\n"
"#  |     |        10\n"
"#  |     false\n"
"#  [1, 5, 50]"
msgstr ""

# @example Pass patterns
msgid ""
"assert {true}               # => pass\n"
"assert {[1, 2].include?(1)} # => pass"
msgstr ""

# @example Failure patterns
msgid ""
"assert {nil}                # => failure\n"
"assert {false}              # => failure\n"
"assert {[1, 2].include?(5)} # => failure"
msgstr ""

# @yield
msgid "[] Given no parameters to the block."
msgstr ""

# @yieldreturn [Object]
msgid "The checked object."
msgstr ""

# Test::Unit::Assertions#assert
msgid "Asserts that `object` is not false nor nil."
msgstr ""

# Test::Unit::Assertions#assert
msgid "Asserts that the givens block returns not false nor nil."
msgstr ""

# Test::Unit::Assertions#assert
msgid ""
"Normally, you don't need to use this assertion. Use more\n"
"specific assertions such as #assert_equal and\n"
"#assert_include."
msgstr ""

# Test::Unit::Assertions#assert
msgid ""
"This style uses Power Assert. It means that you can see each\n"
"object values in method chains on failure. See the following\n"
"example about Power Assert."
msgstr ""

# Test::Unit::Assertions#assert
msgid ""
"We recommend you to use Power Assert for predicate method\n"
"checks rather than existing assertions such as\n"
"#assert_include and #assert_predicate. Power Assert shows\n"
"useful message for debugging."
msgstr ""

# Test::Unit::Assertions#assert
msgid ""
"We don't recommend you use Power Assert for equality\n"
"check. You should use #assert_equal for the case. Because\n"
"#assert_equal shows more useful message for debugging."
msgstr ""

# Test::Unit::Assertions#refute
msgid "Asserts that `object` is false or nil."
msgstr ""

# @example Pass patterns
msgid ""
"refute(false)    # => pass\n"
"refute(nil)      # => pass"
msgstr ""

# @example Fialure patterns
msgid ""
"refute(true)     # => failure\n"
"refute(\"string\") # => failure"
msgstr ""

msgid "Just for minitest compatibility. :<"
msgstr "minitestとの互換製のためだけのリリースです。 :"

# @param [Object] object
msgid "The object to be asserted."
msgstr ""

# @since
msgid "2.5.3"
msgstr ""

# Test::Unit::Assertions#assert_equal
msgid "Passes if `expected` == `actual`."
msgstr ""

# Test::Unit::Assertions#assert_equal
msgid ""
"Note that the ordering of arguments is important, since a helpful\n"
"error message is generated when this one fails that tells you the\n"
"values of expected and actual."
msgstr ""

# @example
msgid "assert_equal 'MY STRING', 'my string'.upcase"
msgstr ""

# Test::Unit::Assertions#assert_raise
# Test::Unit::Assertions#assert_raises
msgid ""
"Passes if the block raises one of the expected\n"
"exceptions. When an expected exception is an Exception\n"
"object, passes if expected_exception == actual_exception."
msgstr ""

# @example
msgid ""
"assert_raise(RuntimeError, LoadError) do\n"
"  raise 'Boom!!!'\n"
"end # -> pass\n"
"\n"
"assert_raise do\n"
"  raise Exception, 'Any exception should be raised!!!'\n"
"end # -> pass\n"
"\n"
"assert_raise(RuntimeError.new(\"XXX\")) {raise \"XXX\"} # -> pass\n"
"assert_raise(MyError.new(\"XXX\"))      {raise \"XXX\"} # -> fail\n"
"assert_raise(RuntimeError.new(\"ZZZ\")) {raise \"XXX\"} # -> fail"
msgstr ""

msgid ""
"Passes if the block raises one of the expected\n"
"exceptions. When an expected exception is an Exception\n"
"object, passes if expected_exception == actual_exception.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_raise_kind_of
msgid ""
"Passes if the block raises one of the given\n"
"exceptions or sub exceptions of the given exceptions."
msgstr ""

# @example
msgid ""
"assert_raise_kind_of(SystemCallError) do\n"
"  raise Errno::EACCES\n"
"end"
msgstr ""

# Test::Unit::Assertions#assert_instance_of
msgid ""
"Passes if `object`.instance_of?(`klass`). When `klass` is\n"
"an array of classes, it passes if any class\n"
"satisfies +object.instance_of?(class)."
msgstr ""

# @example
msgid ""
"assert_instance_of(String, 'foo')            # -> pass\n"
"assert_instance_of([Fixnum, NilClass], 100)  # -> pass\n"
"assert_instance_of([Numeric, NilClass], 100) # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_instance_of
msgid ""
"Passes if `object`.instance_of?(`klass`) does not hold.\n"
"When `klass` is an array of classes, it passes if no class\n"
"satisfies +object.instance_of?(class)."
msgstr ""

# @example
msgid ""
"assert_not_instance_of(String, 100)                # -> pass\n"
"assert_not_instance_of([Fixnum, NilClass], '100')  # -> pass\n"
"assert_not_instance_of([Numeric, NilClass], 100)   # -> fail"
msgstr ""

# @since
msgid "3.0.0"
msgstr ""

msgid ""
"Passes if `object`.instance_of?(`klass`) does not hold.\n"
"When `klass` is an array of classes, it passes if no class\n"
"satisfies +object.instance_of?(class).\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_nil
msgid "Passes if `object` is nil."
msgstr ""

# @example
msgid "assert_nil [1, 2].uniq!"
msgstr ""

# Test::Unit::Assertions#assert_kind_of
msgid ""
"Passes if `object`.kind_of?(`klass`). When `klass` is\n"
"an array of classes or modules, it passes if any\n"
"class or module satisfies +object.kind_of?(class_or_module)."
msgstr ""

# @example
msgid ""
"assert_kind_of(Object, 'foo')                # -> pass\n"
"assert_kind_of([Fixnum, NilClass], 100)      # -> pass\n"
"assert_kind_of([Fixnum, NilClass], \"string\") # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_kind_of
msgid ""
"Passes if `object`.kind_of?(`klass`) does not hold.\n"
"When `klass` is an array of classes or modules, it passes only if all\n"
"classes (and modules) do not satisfy +object.kind_of?(class_or_module)."
msgstr ""

# @example
msgid ""
"assert_not_kind_of(Fixnum, 'foo')           # -> pass\n"
"assert_not_kind_of([Fixnum, NilClass], '0') # -> pass\n"
"assert_not_kind_of([Fixnum, NilClass], 100) # -> fail"
msgstr ""

msgid ""
"Passes if `object`.kind_of?(`klass`) does not hold.\n"
"When `klass` is an array of classes or modules, it passes only if all\n"
"classes (and modules) do not satisfy +object.kind_of?(class_or_module).\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_respond_to
msgid "Passes if `object` .respond_to? `method`"
msgstr ""

# @example
msgid "assert_respond_to 'bugbear', :slice"
msgstr ""

# Test::Unit::Assertions#assert_not_respond_to
msgid "Passes if `object` does not .respond_to? `method`."
msgstr ""

# @example
msgid ""
"assert_not_respond_to('bugbear', :nonexistence) # -> pass\n"
"assert_not_respond_to('bugbear', :size)         # -> fail"
msgstr ""

msgid ""
"Passes if `object` does not .respond_to? `method`.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_match
msgid "Passes if `pattern` =~ `string`."
msgstr ""

# @example
msgid "assert_match(/\\d+/, 'five, 6, seven')"
msgstr ""

# Test::Unit::Assertions#assert_same
msgid ""
"Passes if `actual` .equal? `expected` (i.e. they are the same\n"
"instance)."
msgstr ""

# @example
msgid ""
"o = Object.new\n"
"assert_same o, o"
msgstr ""

# Test::Unit::Assertions#assert_not_operator
# Test::Unit::Assertions#assert_operator
# Test::Unit::Assertions#refute_operator
msgid "Compares the `object1` with `object2` using `operator`."
msgstr ""

# Test::Unit::Assertions#assert_operator
msgid "Passes if object1.__send__(operator, object2) is true."
msgstr ""

# @example
msgid "assert_operator 5, :>=, 4"
msgstr ""

# Test::Unit::Assertions#assert_not_operator
# Test::Unit::Assertions#refute_operator
msgid "Passes if object1.__send__(operator, object2) is not true."
msgstr ""

# @example
msgid ""
"assert_not_operator(5, :<, 4) # => pass\n"
"assert_not_operator(5, :>, 4) # => fail"
msgstr ""

msgid ""
"Passes if object1.__send__(operator, object2) is not true.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_nothing_raised
msgid "Passes if block does not raise an exception."
msgstr ""

# @example
msgid ""
"assert_nothing_raised do\n"
"  [1, 2].uniq\n"
"end"
msgstr ""

# Test::Unit::Assertions#flunk
msgid "Flunk always fails."
msgstr ""

# @example
msgid "flunk 'Not done testing yet.'"
msgstr ""

# Test::Unit::Assertions#assert_not_same
msgid "Passes if ! `actual` .equal? `expected`"
msgstr ""

# @example
msgid "assert_not_same Object.new, Object.new"
msgstr ""

msgid ""
"Passes if ! `actual` .equal? `expected`\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_not_equal
msgid "Passes if `expected` != `actual`"
msgstr ""

# @example
msgid "assert_not_equal 'some string', 5"
msgstr ""

msgid ""
"Passes if `expected` != `actual`\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_not_nil
msgid "Passes if ! `object` .nil?"
msgstr ""

# @example
msgid "assert_not_nil '1 two 3'.sub!(/two/, '2')"
msgstr ""

msgid ""
"Passes if ! `object` .nil?\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_no_match
# Test::Unit::Assertions#assert_not_match
msgid "Passes if `regexp` !~ `string`"
msgstr ""

# @example
msgid ""
"assert_not_match(/two/, 'one 2 three')   # -> pass\n"
"assert_not_match(/three/, 'one 2 three') # -> fail"
msgstr ""

msgid ""
"Passes if `regexp` !~ `string`\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_no_match
msgid "Deprecated. Use #assert_not_match instead."
msgstr ""

# @example
msgid ""
"assert_no_match(/two/, 'one 2 three')   # -> pass\n"
"assert_no_match(/three/, 'one 2 three') # -> fail"
msgstr ""

# @return [ThrowTagExtractor]
msgid "a new instance of ThrowTagExtractor"
msgstr ""

# Test::Unit::Assertions#assert_throw
msgid "Passes if the block throws `expected_object`"
msgstr ""

# @example
msgid ""
"assert_throw(:done) do\n"
"  throw(:done)\n"
"end"
msgstr ""

msgid ""
"Passes if the block throws `expected_object`\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_nothing_thrown
msgid "Passes if block does not throw anything."
msgstr ""

# @example
msgid ""
"assert_nothing_thrown do\n"
"  [1, 2].uniq\n"
"end"
msgstr ""

# Test::Unit::Assertions#assert_in_delta
msgid ""
"Passes if `expected_float` and `actual_float` are equal\n"
"within `delta` tolerance."
msgstr ""

# @example
msgid "assert_in_delta 0.05, (50000.0 / 10**6), 0.00001"
msgstr ""

# Test::Unit::Assertions#assert_not_in_delta
msgid ""
"Passes if `expected_float` and `actual_float` are\n"
"not equal within `delta` tolerance."
msgstr ""

# @example
msgid ""
"assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass\n"
"assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail"
msgstr ""

msgid ""
"Passes if `expected_float` and `actual_float` are\n"
"not equal within `delta` tolerance.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_in_epsilon
msgid ""
"Passes if `expected_float` and `actual_float` are equal\n"
"within `epsilon` relative error of `expected_float`."
msgstr ""

# @example
msgid ""
"assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass\n"
"assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_in_epsilon
msgid ""
"Passes if `expected_float` and `actual_float` are\n"
"not equal within `epsilon` relative error of\n"
"`expected_float`."
msgstr ""

# @example
msgid ""
"assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail\n"
"assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass"
msgstr ""

msgid ""
"Passes if `expected_float` and `actual_float` are\n"
"not equal within `epsilon` relative error of\n"
"`expected_float`.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_send
msgid "Passes if the method send returns a true value."
msgstr ""

# Test::Unit::Assertions#assert_not_send
# Test::Unit::Assertions#assert_send
msgid ""
"`send_array` is composed of:\n"
"* A receiver\n"
"* A method\n"
"* Arguments to the method"
msgstr ""

# @example
msgid ""
"assert_send([[1, 2], :member?, 1]) # -> pass\n"
"assert_send([[1, 2], :member?, 4]) # -> fail"
msgstr ""

msgid "Passes if the method send doesn't return a true value."
msgstr ""

# @example
msgid ""
"assert_not_send([[1, 2], :member?, 1]) # -> fail\n"
"assert_not_send([[1, 2], :member?, 4]) # -> pass"
msgstr ""

# Test::Unit::Assertions#assert_boolean
msgid "Passes if `actual` is a boolean value."
msgstr ""

# @example
msgid ""
"assert_boolean(true) # -> pass\n"
"assert_boolean(nil)  # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_true
msgid "Passes if `actual` is true."
msgstr ""

# @example
msgid ""
"assert_true(true)  # -> pass\n"
"assert_true(:true) # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_false
msgid "Passes if `actual` is false."
msgstr ""

# @example
msgid ""
"assert_false(false)  # -> pass\n"
"assert_false(nil)    # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_compare
msgid ""
"Passes if expression \"`expected` `operator`\n"
"`actual`\" is true."
msgstr ""

# @example
msgid ""
"assert_compare(1, \"<\", 10)  # -> pass\n"
"assert_compare(1, \">=\", 10) # -> fail"
msgstr ""

msgid "Passes if assertion is failed in block."
msgstr ""

# @example
msgid ""
"assert_fail_assertion {assert_equal(\"A\", \"B\")}  # -> pass\n"
"assert_fail_assertion {assert_equal(\"A\", \"A\")}  # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_raise_message
msgid ""
"Passes if an exception is raised in block and its\n"
"message is `expected`."
msgstr ""

# @example
msgid ""
"assert_raise_message(\"exception\") {raise \"exception\"}  # -> pass\n"
"assert_raise_message(/exc/i) {raise \"exception\"}       # -> pass\n"
"assert_raise_message(\"exception\") {raise \"EXCEPTION\"}  # -> fail\n"
"assert_raise_message(\"exception\") {}                   # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_const_defined
msgid "Passes if `object`.const_defined?(`constant_name`)"
msgstr ""

# @example
msgid ""
"assert_const_defined(Test, :Unit)          # -> pass\n"
"assert_const_defined(Object, :Nonexistent) # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_const_defined
msgid "Passes if !`object`.const_defined?(`constant_name`)"
msgstr ""

# @example
msgid ""
"assert_not_const_defined(Object, :Nonexistent) # -> pass\n"
"assert_not_const_defined(Test, :Unit)          # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_predicate
msgid "Passes if `object`.`predicate` is _true_."
msgstr ""

# @example
msgid ""
"assert_predicate([], :empty?)  # -> pass\n"
"assert_predicate([1], :empty?) # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_predicate
msgid "Passes if `object`.`predicate` is not _true_."
msgstr ""

# @example
msgid ""
"assert_not_predicate([1], :empty?) # -> pass\n"
"assert_not_predicate([], :empty?)  # -> fail"
msgstr ""

msgid ""
"Passes if `object`.`predicate` is not _true_.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_alias_method
msgid ""
"Passes if `object`#`alias_name` is an alias method of\n"
"`object`#`original_name`."
msgstr ""

# @example
msgid ""
"assert_alias_method([], :length, :size)  # -> pass\n"
"assert_alias_method([], :size, :length)  # -> pass\n"
"assert_alias_method([], :each, :size)    # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_path_exist
msgid "Passes if `path` exists."
msgstr ""

# @example
msgid ""
"assert_path_exist(\"/tmp\")          # -> pass\n"
"assert_path_exist(\"/bin/sh\")       # -> pass\n"
"assert_path_exist(\"/nonexistent\")  # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_path_not_exist
msgid "Passes if `path` doesn't exist."
msgstr ""

# @example
msgid ""
"assert_path_not_exist(\"/nonexistent\")  # -> pass\n"
"assert_path_not_exist(\"/tmp\")          # -> fail\n"
"assert_path_not_exist(\"/bin/sh\")       # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_include
msgid "Passes if `collection` includes `object`."
msgstr ""

# @example
msgid ""
"assert_include([1, 10], 1)            # -> pass\n"
"assert_include(1..10, 5)              # -> pass\n"
"assert_include([1, 10], 5)            # -> fail\n"
"assert_include(1..10, 20)             # -> fail"
msgstr ""

msgid ""
"Passes if `collection` includes `object`.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_not_include
msgid "Passes if `collection` doesn't include `object`."
msgstr ""

# @example
msgid ""
"assert_not_include([1, 10], 5)            # -> pass\n"
"assert_not_include(1..10, 20)             # -> pass\n"
"assert_not_include([1, 10], 1)            # -> fail\n"
"assert_not_include(1..10, 5)              # -> fail"
msgstr ""

msgid ""
"Passes if `collection` doesn't include `object`.\n"
"Just for minitest compatibility. :<"
msgstr ""

# Test::Unit::Assertions#assert_empty
msgid "Passes if `object` is empty."
msgstr ""

# @example
msgid ""
"assert_empty(\"\")                       # -> pass\n"
"assert_empty([])                       # -> pass\n"
"assert_empty({})                       # -> pass\n"
"assert_empty(\" \")                      # -> fail\n"
"assert_empty([nil])                    # -> fail\n"
"assert_empty({1 => 2})                 # -> fail"
msgstr ""

# Test::Unit::Assertions#assert_not_empty
msgid "Passes if `object` is not empty."
msgstr ""

# @example
msgid ""
"assert_not_empty(\" \")                      # -> pass\n"
"assert_not_empty([nil])                    # -> pass\n"
"assert_not_empty({1 => 2})                 # -> pass\n"
"assert_not_empty(\"\")                       # -> fail\n"
"assert_not_empty([])                       # -> fail\n"
"assert_not_empty({})                       # -> fail"
msgstr ""

msgid ""
"Passes if `object` is not empty.\n"
"Just for minitest compatibility. :<"
msgstr ""

msgid ""
"Builds a failure message.  `user_message` is added before the\n"
"`template` and `arguments` replaces the '?'s positionally in\n"
"the template."
msgstr ""

# Test::Unit::Assertions#add_assertion
msgid ""
"Called whenever an assertion is made. Define this in classes\n"
"that include Test::Unit::Assertions to record assertion\n"
"counts."
msgstr ""

msgid "This is a public API for developers who extend test-unit."
msgstr ""

# Test::Unit::Assertions.use_pp=
msgid ""
"Select whether or not to use the pretty-printer. If this option is set\n"
"to false before any assertions are made, pp.rb will not be required."
msgstr ""

# @param value
msgid "the value to set the attribute use_pp to."
msgstr ""

# Test::Unit::Assertions::AssertionMessage.use_pp
msgid "Returns the value of attribute use_pp"
msgstr ""

# Test::Unit::Assertions::AssertionMessage.use_pp=
msgid "Sets the attribute use_pp"
msgstr ""

msgid "Returns the value of attribute object"
msgstr ""

# @return [Inspector]
msgid "a new instance of Inspector"
msgstr ""

# @return [NumericInspector]
msgid "a new instance of NumericInspector"
msgstr ""

# @return [HashInspector]
msgid "a new instance of HashInspector"
msgstr ""

# @return [ArrayInspector]
msgid "a new instance of ArrayInspector"
msgstr ""

msgid "a new instance of Literal"
msgstr ""

# @return [DelayedLiteral]
msgid "a new instance of DelayedLiteral"
msgstr ""

msgid "a new instance of MaybeContainer"
msgstr ""

msgid "Returns the value of attribute count"
msgstr ""

# @return [Template]
msgid "a new instance of Template"
msgstr ""

# @return [AssertionMessage]
msgid "a new instance of AssertionMessage"
msgstr ""

msgid "Returns the value of attribute exception"
msgstr ""

# @return [WrappedException]
msgid "a new instance of WrappedException"
msgstr ""

# @return [AssertExceptionHelper]
msgid "a new instance of AssertExceptionHelper"
msgstr ""

# @return [AttributeMatcher]
msgid "a new instance of AttributeMatcher"
msgstr ""

# Test::Unit::Attribute::ClassMethods#attribute
msgid "Set an attribute to test methods."
msgstr ""

# @overload
msgid "tag|overload|attribute"
msgstr ""

# @example
msgid ""
"attribute :speed, :slow\n"
"def test_my_slow_method\n"
"  self[:speed] # => :slow\n"
"end"
msgstr ""

# @param [String]
msgid "tag|param|name"
msgstr ""

# @param [Object] name
msgid "the attribute name"
msgstr ""

# @param [Object] value
msgid "the attribute value"
msgstr ""

# @example
msgid ""
"def test_my_slow_method1\n"
"  self[:speed] # => :slow\n"
"end\n"
"\n"
"attribute :speed, :slow, :test_my_slow_method1, :test_my_slow_method2\n"
"\n"
"def test_my_slow_method2\n"
"  self[:speed] # => :slow\n"
"end"
msgstr ""

# @param [Array]
msgid "tag|param|method_names"
msgstr ""

# @param [Array] method_names
msgid "the test method names set the attribute"
msgstr ""

# @example
msgid ""
"attribute :speed, :slow, keep: true\n"
"def test_my_slow_method1\n"
"  self[:speed] # => :slow\n"
"end\n"
"\n"
"def test_my_slow_method2\n"
"  self[:speed] # => :slow\n"
"end"
msgstr ""

# @option
msgid "tag|option|options"
msgstr ""

# @example
msgid ""
"def test_my_slow_method1\n"
"  self[:speed] # => :slow\n"
"end\n"
"\n"
"# There are no valid options for now.\n"
"attribute :speed, :slow, {}, :test_my_slow_method1\n"
"\n"
"def test_my_slow_method2\n"
"  self[:speed] # => nil\n"
"end"
msgstr ""

# @param [Hash]
msgid "tag|param|options"
msgstr ""

# @param [Hash] options
msgid "ignored"
msgstr ""

msgid "Returns the value of attribute suite"
msgstr ""

msgid "Returns the value of attribute runner_options"
msgstr ""

# @param value
msgid "the value to set the attribute filters to."
msgstr ""

# @param value
msgid "the value to set the attribute to_run to."
msgstr ""

msgid "Returns the value of attribute filters"
msgstr ""

# Test::Unit::AutoRunner#filters=
msgid "Sets the attribute filters"
msgstr ""

msgid "Returns the value of attribute to_run"
msgstr ""

# Test::Unit::AutoRunner#to_run=
msgid "Sets the attribute to_run"
msgstr ""

# @param value
msgid "the value to set the attribute default_test_paths to."
msgstr ""

# Test::Unit::AutoRunner#default_test_paths
# Test::Unit::Collector::Load#default_test_paths
msgid "Returns the value of attribute default_test_paths"
msgstr ""

# Test::Unit::AutoRunner#default_test_paths=
msgid "Sets the attribute default_test_paths"
msgstr ""

# @param value
msgid "the value to set the attribute pattern to."
msgstr ""

# @param value
msgid "the value to set the attribute exclude to."
msgstr ""

# @param value
msgid "the value to set the attribute base to."
msgstr ""

# @param value
msgid "the value to set the attribute workdir to."
msgstr ""

msgid "Returns the value of attribute pattern"
msgstr ""

# Test::Unit::AutoRunner#pattern=
msgid "Sets the attribute pattern"
msgstr ""

msgid "Returns the value of attribute exclude"
msgstr ""

# Test::Unit::AutoRunner#exclude=
msgid "Sets the attribute exclude"
msgstr ""

msgid "Returns the value of attribute base"
msgstr ""

# Test::Unit::AutoRunner#base=
# Test::Unit::Collector::Dir#base=
msgid "Sets the attribute base"
msgstr ""

msgid "Returns the value of attribute workdir"
msgstr ""

# Test::Unit::AutoRunner#workdir=
msgid "Sets the attribute workdir"
msgstr ""

msgid "the value to set the attribute color_scheme to."
msgstr ""

# @param value
msgid "the value to set the attribute listeners to."
msgstr ""

msgid "Returns the value of attribute color_scheme"
msgstr ""

msgid "Sets the attribute color_scheme"
msgstr ""

msgid "Returns the value of attribute listeners"
msgstr ""

# Test::Unit::AutoRunner#listeners=
msgid "Sets the attribute listeners"
msgstr ""

# @param value
msgid "the value to set the attribute stop_on_failure to."
msgstr ""

# Test::Unit::AutoRunner#stop_on_failure=
msgid "Sets the attribute stop_on_failure"
msgstr ""

msgid "the value to set the attribute runner to."
msgstr ""

msgid "the value to set the attribute collector to."
msgstr ""

msgid "Sets the attribute runner"
msgstr ""

msgid "Sets the attribute collector"
msgstr ""

msgid "a new instance of AutoRunner"
msgstr ""

# @yieldparam [Test::Unit::AutoRunner]
msgid "tag|yieldparam|_self"
msgstr ""

msgid "the object that the method was called on"
msgstr ""

# @return [CodeSnippetFetcher]
msgid "a new instance of CodeSnippetFetcher"
msgstr ""

msgid "a new instance of Dir"
msgstr ""

msgid "Returns the value of attribute patterns"
msgstr ""

msgid "Returns the value of attribute excludes"
msgstr ""

msgid "a new instance of Load"
msgstr ""

# @return [ObjectSpace]
msgid "a new instance of ObjectSpace"
msgstr ""

msgid "Returns the value of attribute test_suites"
msgstr ""

msgid "a new instance of Listener"
msgstr ""

# @return [ColorScheme]
msgid "a new instance of ColorScheme"
msgstr ""

msgid "Returns the value of attribute name"
msgstr ""

# @return [Color]
msgid "a new instance of Color"
msgstr ""

msgid "Returns the value of attribute colors"
msgstr ""

# @return [MixColor]
msgid "a new instance of MixColor"
msgstr ""

# @return [DataSets]
msgid "a new instance of DataSets"
msgstr ""

msgid "This method provides Data-Driven-Test functionality."
msgstr "データ駆動テスト機能のドキュメントを追加しました。"

# Test::Unit::Data::ClassMethods#data
msgid "Define test data in the test code."
msgstr ""

# @overload
msgid "tag|overload|data"
msgstr ""

# @example
msgid "tag|example|data(label, data)"
msgstr ""

# @example data(label, data)
msgid ""
"data(\"empty string\", [true, \"\"])\n"
"data(\"plain string\", [false, \"hello\"])\n"
"def test_empty?(data)\n"
"  expected, target = data\n"
"  assert_equal(expected, target.empty?)\n"
"end"
msgstr ""

# @param [String]
msgid "tag|param|label"
msgstr ""

# @param [String] label
msgid "specify test case name."
msgstr ""

# @param
msgid "tag|param|data"
msgstr ""

# @param data
msgid "specify test data."
msgstr ""

# @param [Hash] options
msgid "specify options."
msgstr ""

# @example
msgid "tag|example|data(variable, patterns)"
msgstr ""

# @example data(variable, patterns)
msgid ""
"data(:x, [1, 2, 3])\n"
"data(:y, [\"a\", \"b\"])\n"
"def test_patterns(data)\n"
"  # 3 * 2 times executed\n"
"  # 3: the number of patterns of :x\n"
"  # 2: the number of patterns of :y\n"
"  p data\n"
"    # => {:x => 1, :y => \"a\"}\n"
"    # => {:x => 1, :y => \"b\"}\n"
"    # => {:x => 2, :y => \"a\"}\n"
"    # => {:x => 2, :y => \"b\"}\n"
"    # => {:x => 3, :y => \"a\"}\n"
"    # => {:x => 3, :y => \"b\"}\n"
"end"
msgstr ""

# @param [Symbol]
msgid "tag|param|variable"
msgstr ""

# @param [Symbol] variable
msgid "specify test pattern variable name."
msgstr ""

# @param [Array]
msgid "tag|param|patterns"
msgstr ""

# @param [Array] patterns
msgid "specify test patterns for the variable."
msgstr ""

# @example
msgid "tag|example|data(data_set)"
msgstr ""

# @example data(data_set)
msgid ""
"data(\"empty string\" => [true, \"\"],\n"
"     \"plain string\" => [false, \"hello\"])\n"
"def test_empty?(data)\n"
"  expected, target = data\n"
"  assert_equal(expected, target.empty?)\n"
"end"
msgstr ""

# @param [Hash]
msgid "tag|param|data_set"
msgstr ""

# @param [Hash] data_set
msgid ""
"specify test data as a Hash that\n"
"key is test label and value is test data."
msgstr ""

# @example
msgid "tag|example|data(&block)"
msgstr ""

# @example data(&block)
msgid ""
"data do\n"
"  data_set = {}\n"
"  data_set[\"empty string\"] = [true, \"\"]\n"
"  data_set[\"plain string\"] = [false, \"hello\"]\n"
"  data_set\n"
"end\n"
"def test_empty?(data)\n"
"  expected, target = data\n"
"  assert_equal(expected, target.empty?)\n"
"end"
msgstr ""

# @yieldreturn [Hash]
msgid ""
"return test data set\n"
"as a Hash that key is test label and value is test data."
msgstr ""

# @example data(&block)
msgid ""
"data do\n"
"  patterns = 3.times.to_a\n"
"  [:x, patterns]\n"
"end\n"
"data do\n"
"  patterns = []\n"
"  character = \"a\"\n"
"  2.times.each do\n"
"    patterns << character\n"
"    character = character.succ\n"
"  end\n"
"  [:y, patterns]\n"
"end\n"
"def test_patterns(data)\n"
"  # 3 * 2 times executed\n"
"  # 3: the number of patterns of :x\n"
"  # 2: the number of patterns of :y\n"
"  p data\n"
"    # => {:x => 0, :y => \"a\"}\n"
"    # => {:x => 0, :y => \"b\"}\n"
"    # => {:x => 1, :y => \"a\"}\n"
"    # => {:x => 1, :y => \"b\"}\n"
"    # => {:x => 2, :y => \"a\"}\n"
"    # => {:x => 2, :y => \"b\"}\n"
"end"
msgstr ""

# @yieldreturn [Array]
msgid ""
"return test data set\n"
"as an Array of variable and patterns."
msgstr ""

# Test::Unit::Data::ClassMethods#data
msgid "Generates test matrix from variable and patterns pairs."
msgstr ""

# Test::Unit::Data::ClassMethods#load_data
msgid ""
"Load test data from the file. This is shorthand to load\n"
"test data from file.  If you want to load complex file, you\n"
"can use {#data} with block."
msgstr ""

msgid "tag|example|Load data from CSV file"
msgstr "CSVファイルからデータを読み込みます。"

# @example Load data from CSV file
msgid ""
"load_data(\"/path/to/test-data.csv\")\n"
"def test_empty?(data)\n"
"  assert_equal(data[\"expected\"], data[\"target\"].empty?)\n"
"end"
msgstr ""

# @param [String]
msgid "tag|param|file_name"
msgstr ""

msgid ""
"full path to test data file.\n"
"File format is automatically detected from filename extension."
msgstr "データファイルのフルパスを指定します。ファイルフォーマットはファイルの拡張子から自動的に判別します。"

msgid "if `file_name` is not supported file format."
msgstr "`file_name` がサポートされていないファイルフォーマットのときに発生します。"

# @see
msgid "tag|see|Loader#load"
msgstr ""

msgid "a new instance of Loader"
msgstr ""

msgid "Load data from file."
msgstr "ファイルからデータを読み込みます。"

# @see
msgid "tag|see|#load_csv"
msgstr ""

# @see
msgid "tag|see|#load_tsv"
msgstr ""

msgid "Load data from CSV file."
msgstr "CSVファイルからデータを読み込みます。"

msgid ""
"There are 2 types of CSV file as following examples.\n"
"First, there is a header on first row and it's first column is \"label\".\n"
"Another, there is no header in the file."
msgstr ""
"以下の2種類のサンプルのようなCSVファイルを使用できます。\n"
"一つ目は、一行目の最初のカラムが\"label\"という文字列であるものです。\n"
"もう一つは、ヘッダ行のないファイルです。"

msgid "tag|example|Load data from CSV file with header"
msgstr "ヘッダのあるCSVファイルを読み込みます"

# @example Load data from CSV file with header
msgid ""
"# test-data.csv:\n"
"#  label,expected,target\n"
"#  empty string,true,\"\"\n"
"#  plain string,false,hello\n"
"#\n"
"load_data(\"/path/to/test-data.csv\")\n"
"def test_empty?(data)\n"
"  assert_equal(data[\"expected\"], data[\"target\"].empty?)\n"
"end"
msgstr ""

msgid "tag|example|Load data from CSV file without header"
msgstr "ヘッダのないCSVファイルを読み込みます"

# @example Load data from CSV file without header
msgid ""
"# test-data-without-header.csv:\n"
"#  empty string,true,\"\"\n"
"#  plain string,false,hello\n"
"#\n"
"load_data(\"/path/to/test-data-without-header.csv\")\n"
"def test_empty?(data)\n"
"  expected, target = data\n"
"  assert_equal(expected, target.empty?)\n"
"end"
msgstr ""

msgid "Load data from TSV file."
msgstr "TSVファイルからデータを読み込みます。"

msgid ""
"There are 2 types of TSV file as following examples.\n"
"First, there is a header on first row and it's first column is \"label\".\n"
"Another, there is no header in the file."
msgstr ""
"以下の2種類のサンプルのようなTSVファイルを使用できます。\n"
"一つ目は、一行目の最初のカラムが\"label\"という文字列であるものです。\n"
"もう一つは、ヘッダ行のないファイルです。"

msgid "tag|example|Load data from TSV file with header"
msgstr "ヘッダのあるTSVファイルを読み込みます"

# @example Load data from TSV file with header
msgid ""
"# test-data.tsv:\n"
"#  label\texpected\ttarget\n"
"#  empty string\ttrue\t\"\"\n"
"#  plain string\tfalse\thello\n"
"#\n"
"load_data(\"/path/to/test-data.tsv\")\n"
"def test_empty?(data)\n"
"  assert_equal(data[\"expected\"], data[\"target\"].empty?)\n"
"end"
msgstr ""

msgid "tag|example|Load data from TSV file without header"
msgstr "ヘッダのないTSVファイルを読み込みます"

# @example Load data from TSV file without header
msgid ""
"# test-data-without-header.tsv:\n"
"#  empty string\ttrue\t\"\"\n"
"#  plain string\tfalse\thello\n"
"#\n"
"load_data(\"/path/to/test-data-without-header.tsv\")\n"
"def test_empty?(data)\n"
"  expected, target = data\n"
"  assert_equal(expected, target.empty?)\n"
"end"
msgstr ""

# @return [SequenceMatcher]
msgid "a new instance of SequenceMatcher"
msgstr ""

msgid "a new instance of Differ"
msgstr ""

# Test::Unit::Diff::UTF8Line::WIDE_CHARACTERS
msgid "from http://unicode.org/reports/tr11/"
msgstr ""

# @return [UTF8Line]
msgid "a new instance of UTF8Line"
msgstr ""

# Test::Unit::Error
msgid ""
"Encapsulates an error in a test. Created by\n"
"Test::Unit::TestCase when it rescues an exception thrown\n"
"during the processing of a test."
msgstr ""

msgid "Returns the value of attribute test_name"
msgstr ""

msgid "Returns the value of attribute method_name"
msgstr ""

# Test::Unit::Error#initialize
msgid ""
"Creates a new Error with the given test_name and\n"
"exception."
msgstr ""

msgid "a new instance of Error"
msgstr ""

msgid "Returns a single character representation of an error."
msgstr ""

msgid "Returns the message associated with the error."
msgstr ""

msgid "Returns a brief version of the error description."
msgstr ""

msgid "Returns a verbose version of the error description."
msgstr ""

# Test::Unit::Error#backtrace
msgid "Deprecated"
msgstr ""

msgid "Overridden to return long_display."
msgstr ""

msgid "Returns the value of attribute errors"
msgstr ""

msgid "Records a Test::Unit::Error."
msgstr ""

# Test::Unit::TestResultErrorSupport#error_count
msgid ""
"Returns the number of errors this TestResult has\n"
"recorded."
msgstr ""

# @overload
msgid "tag|overload|exception_handler"
msgstr ""

# @param [Symbol]
msgid "tag|param|method_name"
msgstr ""

# @param [Symbol] method_name
msgid "The method name that handles exception raised in tests."
msgstr ""

# @yield [test, exception]
msgid "Gives the test and the exception."
msgstr ""

# @yieldparam [Test::Unit::TestCase]
msgid "tag|yieldparam|test"
msgstr ""

# @yieldparam [Test::Unit::TestCase] test
msgid "The test where the exception is raised."
msgstr ""

# @yieldparam [Exception]
msgid "tag|yieldparam|exception"
msgstr ""

# @yieldparam [Exception] exception
msgid "The exception that is raised in running the test."
msgstr ""

# @yieldreturn [Boolean]
msgid ""
"Whether the handler handles the exception or not.\n"
"The handler must return _true_ if the handler handles\n"
"test exception, _false_ otherwise."
msgstr ""

# Test::Unit::ExceptionHandler::ClassMethods#exception_handler
msgid "Add an exception handler method."
msgstr ""

# Test::Unit::ExceptionHandler::ClassMethods#exception_handler
msgid "Add an exception handler."
msgstr ""

# Test::Unit::Failure
msgid ""
"Encapsulates a test failure. Created by Test::Unit::TestCase\n"
"when an assertion fails."
msgstr ""

msgid "Returns the value of attribute location"
msgstr ""

msgid "Returns the value of attribute message"
msgstr ""

msgid "Returns the value of attribute source_location"
msgstr ""

# Test::Unit::Failure#initialize
msgid ""
"Creates a new Failure with the given location and\n"
"message."
msgstr ""

msgid "a new instance of Failure"
msgstr ""

msgid "Returns a single character representation of a failure."
msgstr ""

msgid "Report a failure."
msgstr ""

msgid "The description about the failure."
msgstr ""

# @param [Array]
msgid "tag|param|backtrace"
msgstr ""

msgid "The backtrace for the failure."
msgstr ""

msgid "a customizable set of options"
msgstr ""

msgid "Returns the value of attribute failures"
msgstr ""

msgid "Records a Test::Unit::Failure."
msgstr ""

# Test::Unit::TestResultFailureSupport#failure_count
msgid ""
"Returns the number of failures this TestResult has\n"
"recorded."
msgstr ""

# @return [FaultLocationDetector]
msgid "a new instance of FaultLocationDetector"
msgstr ""

# Test::Unit::Fixture::Fixture#setup
msgid "Returns the value of attribute setup"
msgstr ""

# Test::Unit::Fixture::Fixture#cleanup
msgid "Returns the value of attribute cleanup"
msgstr ""

# Test::Unit::Fixture::Fixture#teardown
msgid "Returns the value of attribute teardown"
msgstr ""

# @return [Fixture]
msgid "a new instance of Fixture"
msgstr ""

# @return [HookPoint]
msgid "a new instance of HookPoint"
msgstr ""

# Test::Unit::Notification#initialize
msgid ""
"Creates a new Notification with the given location and\n"
"message."
msgstr ""

# @return [Notification]
msgid "a new instance of Notification"
msgstr ""

msgid "Returns a single character representation of a notification."
msgstr ""

msgid "Notify some information."
msgstr ""

# Test::Unit::TestCase
msgid "Example:"
msgstr ""

# Test::Unit::TestCaseNotificationSupport#notify
msgid ""
"    def test_notification\n"
"      notify(\"I'm here!\")\n"
"      # Reached here\n"
"      notify(\"Special!\") if special_case?\n"
"      # Reached here too\n"
"    end"
msgstr ""

# Test::Unit::TestCaseNotificationSupport#notify
msgid "options:"
msgstr ""

# Test::Unit::TestCaseNotificationSupport#notify
msgid "    :backtrace override backtrace."
msgstr ""

msgid "Returns the value of attribute notifications"
msgstr ""

msgid "Records a Test::Unit::Notification."
msgstr ""

# Test::Unit::TestResultNotificationSupport#notification_count
msgid ""
"Returns the number of notifications this TestResult has\n"
"recorded."
msgstr ""

# Test::Unit::Omission#initialize
msgid ""
"Creates a new Omission with the given location and\n"
"message."
msgstr ""

# @return [Omission]
msgid "a new instance of Omission"
msgstr ""

msgid "Returns a single character representation of a omission."
msgstr ""

msgid "Omit the test or part of the test."
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit
msgid ""
"    def test_omission\n"
"      omit\n"
"      # Not reached here\n"
"    end"
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit
msgid ""
"    def test_omission_with_here\n"
"      omit do\n"
"        # Not ran here\n"
"      end\n"
"      # Reached here\n"
"    end"
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_if
msgid ""
"Omit the test or part of the test if _condition_ is\n"
"true."
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_if
msgid ""
"    def test_omission\n"
"      omit_if(\"\".empty?)\n"
"      # Not reached here\n"
"    end"
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_if
msgid ""
"    def test_omission_with_here\n"
"      omit_if(true) do\n"
"        # Not ran here\n"
"      end\n"
"      omit_if(false) do\n"
"        # Reached here\n"
"      end\n"
"      # Reached here too\n"
"    end"
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_unless
msgid ""
"Omit the test or part of the test if _condition_ is\n"
"not true."
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_unless
msgid ""
"    def test_omission\n"
"      omit_unless(\"string\".empty?)\n"
"      # Not reached here\n"
"    end"
msgstr ""

# Test::Unit::TestCaseOmissionSupport#omit_unless
msgid ""
"    def test_omission_with_here\n"
"      omit_unless(true) do\n"
"        # Reached here\n"
"      end\n"
"      omit_unless(false) do\n"
"        # Not ran here\n"
"      end\n"
"      # Reached here too\n"
"    end"
msgstr ""

msgid "Returns the value of attribute omissions"
msgstr ""

msgid "Records a Test::Unit::Omission."
msgstr ""

# Test::Unit::TestResultOmissionSupport#omission_count
msgid ""
"Returns the number of omissions this TestResult has\n"
"recorded."
msgstr ""

# Test::Unit::Pending#initialize
msgid ""
"Creates a new Pending with the given location and\n"
"message."
msgstr ""

msgid "a new instance of Pending"
msgstr ""

msgid "Returns a single character representation of a pending."
msgstr ""

msgid "Marks the test or part of the test is pending."
msgstr ""

# Test::Unit::TestCasePendingSupport#pend
msgid ""
"    def test_pending\n"
"      pend\n"
"      # Not reached here\n"
"    end"
msgstr ""

# Test::Unit::TestCasePendingSupport#pend
msgid ""
"    def test_pending_with_here\n"
"      pend do\n"
"        # Ran here\n"
"        # Fails if the block doesn't raise any error.\n"
"        # Because it means the block is passed unexpectedly.\n"
"      end\n"
"      # Reached here\n"
"    end"
msgstr ""

msgid "Returns the value of attribute pendings"
msgstr ""

msgid "Records a Test::Unit::Pending."
msgstr ""

# Test::Unit::TestResultPendingSupport#pending_count
msgid ""
"Returns the number of pendings this TestResult has\n"
"recorded."
msgstr ""

msgid "Returns the value of attribute test"
msgstr ""

# @return [Checker]
msgid "a new instance of Checker"
msgstr ""

# @return [TestSuiteCreator]
msgid "a new instance of TestSuiteCreator"
msgstr ""

# Test::Unit::TestCase
msgid ""
"Ties everything together. If you subclass and add your own\n"
"test methods, it takes care of making them into tests and\n"
"wrapping those tests into a suite. It also does the\n"
"nitty-gritty of actually running an individual test and\n"
"collecting its results into a Test::Unit::TestResult object."
msgstr ""

msgid "You can run two hooks before/after a TestCase run."
msgstr ""

# Test::Unit::TestCase
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      class << self\n"
"        def startup\n"
"          ...\n"
"        end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"        def shutdown\n"
"          ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      def setup\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      def cleanup\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      def teardown\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      def test_my_method1\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      def test_my_method2\n"
"        ...\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"1. startup\n"
"1. setup\n"
"1. test_my_method1\n"
"1. cleanup\n"
"1. teardown\n"
"1. setup\n"
"1. test_my_method2\n"
"1. cleanup\n"
"1. teardown\n"
"1. shutdown"
msgstr ""

# Test::Unit::TestCase
msgid "You can set an attribute to each test."
msgstr ""

# Test::Unit::TestCase
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      attribute :speed, :fast\n"
"      def test_my_fast_method\n"
"        # You can get the attribute via `self[]`\n"
"        self[:speed] # => :fast\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase
msgid ""
"      attribute :speed, :slow\n"
"      def test_my_slow_method\n"
"        self[:speed] # => :slow\n"
"        ...\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase.suite
msgid ""
"Rolls up all of the test* methods in the fixture into\n"
"one suite, creating a new instance of the fixture for\n"
"each method."
msgstr ""

# Test::Unit::TestCase.startup
msgid ""
"Called before every test case runs. Can be used\n"
"to set up fixture information used in test case\n"
"scope."
msgstr ""

# Test::Unit::TestCase.startup
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      class << self\n"
"        def startup\n"
"          ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit::TestCase.shutdown
# Test::Unit::TestCase.startup
msgid ""
"      def test_my_class1\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase.shutdown
# Test::Unit::TestCase.startup
msgid ""
"      def test_my_class2\n"
"        ...\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase.startup
msgid ""
"* startup\n"
"* setup\n"
"* test_my_class1 (or test_my_class2)\n"
"* setup\n"
"* test_my_class2 (or test_my_class1)"
msgstr ""

# Test::Unit::TestCase.shutdown
# Test::Unit::TestCase.startup
msgid ""
"Note that you should not assume test order. Tests\n"
"should be worked in any order."
msgstr ""

# Test::Unit::TestCase.shutdown
msgid ""
"Called after every test case runs. Can be used to tear\n"
"down fixture information used in test case scope."
msgstr ""

# Test::Unit::TestCase.shutdown
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      class << self\n"
"        def shutdown\n"
"          ...\n"
"        end\n"
"      end"
msgstr ""

# Test::Unit::TestCase.shutdown
msgid ""
"* test_my_class1 (or test_my_class2)\n"
"* teardown\n"
"* test_my_class2 (or test_my_class1)\n"
"* teardown\n"
"* shutdown"
msgstr ""

# Test::Unit::TestCase.test_order
msgid ""
"Returns the current test order. This returns\n"
"`:alphabetic` by default."
msgstr ""

msgid "Sets the current test order."
msgstr ""

# Test::Unit::TestCase.test_order=
msgid "Here are the available _order_:"
msgstr ""

# Test::Unit::TestCase.test_order=
msgid ""
":alphabetic\n"
": Default. Tests are sorted in alphabetic order."
msgstr ""

# Test::Unit::TestCase.test_order=
msgid ""
":random\n"
": Tests are sorted in random order."
msgstr ""

# Test::Unit::TestCase.test_order=
msgid ""
":defined\n"
": Tests are sorted in defined order."
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"Defines a test in declarative syntax or marks\n"
"following method as a test method."
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"In declarative syntax usage, the following two\n"
"test definitions are the almost same:"
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"    description \"register user\"\n"
"    def test_register_user\n"
"      ...\n"
"    end"
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"    test \"register user\" do\n"
"      ...\n"
"    end"
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"In test method mark usage, the \"my_test_method\" is\n"
"treated as a test method:"
msgstr ""

# Test::Unit::TestCase.test
msgid ""
"    test\n"
"    def my_test_method\n"
"      assert_equal(\"call me\", ...)\n"
"    end"
msgstr ""

msgid "Describes a test."
msgstr ""

# Test::Unit::TestCase.description
msgid ""
"The following example associates \"register a\n"
"normal user\" description with \"test_register\"\n"
"test."
msgstr ""

# Test::Unit::TestCase.description
msgid ""
"    description \"register a normal user\"\n"
"    def test_register\n"
"      ...\n"
"    end"
msgstr ""

msgid "Defines a sub test case."
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid ""
"This is a syntax sugar. The both of the following codes are\n"
"the same in meaning:"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid "Standard:"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid ""
"    class TestParent < Test::Unit::TestCase\n"
"      class TestChild < self\n"
"        def test_in_child\n"
"        end\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid "Syntax sugar:"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid ""
"    class TestParent < Test::Unit::TestCase\n"
"      sub_test_case(\"TestChild\") do\n"
"        def test_in_child\n"
"        end\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid "The difference of them are the following:"
msgstr ""

# Test::Unit::TestCase.sub_test_case
msgid ""
"* Test case created by {sub_test_case} is an anonymous class.\n"
"  So you can't refer the test case by name.\n"
"* The class name of class style must follow\n"
"  constant naming rule in Ruby. But the name of test case\n"
"  created by {sub_test_case} doesn't need to follow the rule.\n"
"  For example, you can use a space in name such as \"child test\"."
msgstr ""

msgid "The name of newly created sub test case."
msgstr ""

msgid "Created sub test case class."
msgstr ""

# @yield
msgid ""
"The block is evaluated under the newly created sub test\n"
"case class context."
msgstr ""

# @option
msgid "tag|option|query"
msgstr ""

# @param [Hash]
msgid "tag|param|query"
msgstr ""

# Test::Unit::TestCase.test_defined?
msgid ""
"Checks whether a test that is matched the query is\n"
"defined."
msgstr ""

msgid "a new instance of TestCase"
msgstr ""

# Test::Unit::TestCase#initialize
msgid ""
"Creates a new instance of the fixture for running the\n"
"test represented by test_method_name."
msgstr ""

msgid "Assigns test data to the test. It is used in internal."
msgstr ""

msgid "Returns the test is valid test. It is used in internal."
msgstr ""

# Test::Unit::TestCase#run
msgid ""
"Runs the individual test method represented by this\n"
"instance of the fixture, collecting statistics, failures\n"
"and errors in result."
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"Called before every test method runs. Can be used\n"
"to set up fixture information."
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"You can add additional setup tasks by the following\n"
"code:"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      def setup\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"      setup\n"
"      def my_setup1\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"      setup do\n"
"        ... # setup callback1\n"
"      end"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"      setup\n"
"      def my_setup2\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"      setup do\n"
"        ... # setup callback2\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
# Test::Unit::TestCase#setup
# Test::Unit::TestCase#teardown
msgid ""
"      def test_my_class\n"
"        ...\n"
"      end\n"
"    end"
msgstr ""

# Test::Unit::TestCase#setup
msgid ""
"* setup\n"
"* my_setup1\n"
"* setup callback1\n"
"* my_setup2\n"
"* setup callback2\n"
"* test_my_class"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"Called after every test method runs but the test\n"
"method isn't marked as 'passed'. Can be used to\n"
"clean up and/or verify tested condition.\n"
"e.g. Can be used to verify mock."
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"You can add additional cleanup tasks by the following\n"
"code:"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      def cleanup\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"      cleanup\n"
"      def my_cleanup1\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"      cleanup do\n"
"        ... # cleanup callback1\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"      cleanup\n"
"      def my_cleanup2\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"      cleanup do\n"
"        ... # cleanup callback2\n"
"      end"
msgstr ""

# Test::Unit::TestCase#cleanup
msgid ""
"* test_my_class\n"
"* cleanup callback2\n"
"* my_cleanup2\n"
"* cleanup callback1\n"
"* my_cleanup1\n"
"* cleanup"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"Called after every test method runs. Can be used to tear\n"
"down fixture information."
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"You can add additional teardown tasks by the following\n"
"code:"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"    class TestMyClass < Test::Unit::TestCase\n"
"      def teardown\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"      teardown\n"
"      def my_teardown1\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"      teardown do\n"
"        ... # teardown callback1\n"
"      end"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"      teardown\n"
"      def my_teardown2\n"
"        ...\n"
"      end"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"      teardown do\n"
"        ... # teardown callback2\n"
"      end"
msgstr ""

# Test::Unit::TestCase#teardown
msgid ""
"* test_my_class\n"
"* teardown callback2\n"
"* my_teardown2\n"
"* teardown callback1\n"
"* my_teardown1\n"
"* teardown"
msgstr ""

# Test::Unit::TestCase#data_label
msgid ""
"Returns a label of test data for the test. If the\n"
"test isn't associated with any test data, it returns\n"
"`nil`."
msgstr ""

# Test::Unit::TestCase#data
msgid ""
"Returns test data for the test. If the test isn't associated\n"
"with any test data, it returns `nil`."
msgstr ""

# Test::Unit::TestCase#name
msgid ""
"Returns a human-readable name for the specific test that\n"
"this instance of TestCase represents."
msgstr ""

# Test::Unit::TestCase#local_name
msgid ""
"Returns a human-readable name for the specific test that this\n"
"instance of TestCase represents."
msgstr ""

# Test::Unit::TestCase#local_name
msgid ""
"`#local_name` doesn't include class name. `#name` includes\n"
"class name."
msgstr ""

# Test::Unit::TestCase#description
msgid ""
"Returns a description for the test. A description\n"
"will be associated by Test::Unit::TestCase.test or\n"
"Test::Unit::TestCase.description."
msgstr ""

msgid "Returns a name for the test for no description test."
msgstr ""

msgid "Overridden to return #name."
msgstr ""

msgid "It's handy to be able to compare TestCase instances."
msgstr ""

msgid "Returns a Time at the test was started."
msgstr ""

msgid "Returns elapsed time for the test was ran."
msgstr ""

msgid "Returns whether the test is interrupted."
msgstr ""

# Test::Unit::TestCase#passed?
msgid ""
"Returns whether this individual test passed or\n"
"not. Primarily for use in teardown so that artifacts\n"
"can be left behind if the test fails."
msgstr ""

# Test::Unit::TestCase#problem_occurred
msgid ""
"Notify that a problem is occurred in the test. It means that\n"
"the test is a failed test. If any failed tests exist in test\n"
"suites, the test process exits with failure exit status."
msgstr ""

# Test::Unit::TestCase#add_pass
msgid ""
"Notify that the test is passed. Normally, it is not needed\n"
"because #run calls it automatically. If you want to override\n"
"#run, it is not a good idea. Please contact test-unit\n"
"developers. We will help you without your custom #run. For\n"
"example, we may add a new hook in #run."
msgstr ""

msgid "Returns the value of attribute start_time"
msgstr ""

msgid "Returns the value of attribute elapsed_time"
msgstr ""

# Test::Unit::TestCase::InternalData#test_data_label
msgid "Returns the value of attribute test_data_label"
msgstr ""

# Test::Unit::TestCase::InternalData#test_data
msgid "Returns the value of attribute test_data"
msgstr ""

# @return [InternalData]
msgid "a new instance of InternalData"
msgstr ""

# Test::Unit::TestResult
msgid ""
"Collects Test::Unit::Failure and Test::Unit::Error so that\n"
"they can be displayed to the user. To this end, observers\n"
"can be added to it, allowing the dynamic updating of, say, a\n"
"UI."
msgstr ""

msgid "Returns the value of attribute run_count"
msgstr ""

msgid "Returns the value of attribute pass_count"
msgstr ""

msgid "Returns the value of attribute assertion_count"
msgstr ""

msgid "Returns the value of attribute faults"
msgstr ""

# @param value
msgid "the value to set the attribute stop_tag to."
msgstr ""

# Test::Unit::TestResult#stop_tag
msgid "Returns the value of attribute stop_tag"
msgstr ""

# Test::Unit::TestResult#stop_tag=
msgid "Sets the attribute stop_tag"
msgstr ""

msgid "Constructs a new, empty TestResult."
msgstr ""

# @return [TestResult]
msgid "a new instance of TestResult"
msgstr ""

msgid "Records a test run."
msgstr ""

msgid "Records an individual assertion."
msgstr ""

# Test::Unit::TestResult#summary
msgid ""
"Returns a string contain the recorded runs, assertions,\n"
"failures and errors in this TestResult."
msgstr ""

msgid "Returnes a string that shows result status."
msgstr ""

# Test::Unit::TestResult#passed?
msgid ""
"Returns whether or not this TestResult represents\n"
"successful completion."
msgstr ""

msgid "A collection of tests which can be #run."
msgstr ""

# Test::Unit::TestSuite
msgid ""
"Note: It is easy to confuse a TestSuite instance with\n"
"something that has a static suite method; I know because _I_\n"
"have trouble keeping them straight. Think of something that\n"
"has a suite method as simply providing a way to get a\n"
"meaningful TestSuite instance."
msgstr ""

msgid "Returns the value of attribute tests"
msgstr ""

msgid "Returns the value of attribute test_case"
msgstr ""

# Test::Unit::TestSuite#priority
# Test::Unit::TestSuite#priority=
msgid ""
"Test suite that has higher priority is ran prior to\n"
"test suites that have lower priority."
msgstr ""

msgid "Creates a new TestSuite with the given name."
msgstr ""

# @return [TestSuite]
msgid "a new instance of TestSuite"
msgstr ""

# Test::Unit::TestSuite#run
msgid ""
"Runs the tests and/or suites contained in this\n"
"TestSuite."
msgstr ""

msgid "Adds the test to the suite."
msgstr ""

# Test::Unit::TestSuite#size
msgid ""
"Returns the rolled up number of tests in this suite;\n"
"i.e. if the suite contains other suites, it counts the\n"
"tests within those suites, not the suites themselves."
msgstr ""

# Test::Unit::TestSuite#to_s
msgid ""
"Overridden to return the name given the suite at\n"
"creation."
msgstr ""

msgid "It's handy to be able to compare TestSuite instances."
msgstr ""

msgid "Runs a Test::Unit::TestSuite on the console."
msgstr ""

# Test::Unit::UI::Console::TestRunner#initialize
msgid ""
"Creates a new TestRunner for running the passed\n"
"suite. If quiet_mode is true, the output while\n"
"running is limited to progress dots, errors and\n"
"failures, and the final result. io specifies\n"
"where runner output should go to; defaults to\n"
"STDOUT."
msgstr ""

msgid "a new instance of TestRunner"
msgstr ""

# @return [ColorizedReadableDiffer]
msgid "a new instance of ColorizedReadableDiffer"
msgstr ""

msgid "Begins the test run."
msgstr ""

# Test::Unit::UI::TestRunnerMediator
msgid ""
"Provides an interface to write any given UI against,\n"
"hopefully making it easy to write new UIs."
msgstr ""

# Test::Unit::UI::TestRunnerMediator#initialize
msgid ""
"Creates a new TestRunnerMediator initialized to run\n"
"the passed suite."
msgstr ""

# @return [TestRunnerMediator]
msgid "a new instance of TestRunnerMediator"
msgstr ""

# Test::Unit::UI::TestRunnerMediator#run
msgid ""
"Runs the suite the TestRunnerMediator was created\n"
"with."
msgstr ""

# Test::Unit::UI::TestRunnerMediator#run_suite
msgid ""
"Just for backward compatibility for NetBeans.\n"
"NetBeans should not use monkey patching. NetBeans\n"
"should use runner change public API."
msgstr ""

# Test::Unit::UI::TestRunnerMediator#run_suite
msgid ""
"See GitHub#38\n"
"  https://github.com/test-unit/test-unit/issues/38"
msgstr ""

# Test::Unit::UI::TestRunnerMediator#create_result
msgid ""
"A factory method to create the result the mediator\n"
"should run with. Can be overridden by subclasses if\n"
"one wants to use a different result."
msgstr ""

# Test::Unit::UI::TestRunnerUtilities
msgid ""
"Provides some utilities common to most, if not all,\n"
"TestRunners."
msgstr ""

msgid "--"
msgstr ""

# Test::Unit::UI::TestRunnerUtilities
msgid ""
"Perhaps there ought to be a TestRunner superclass? There\n"
"seems to be a decent amount of shared code between test\n"
"runners."
msgstr ""

msgid "Creates a new TestRunner and runs the suite."
msgstr ""

# Test::Unit::UI::TestRunnerUtilities#start_command_line_test
msgid ""
"Takes care of the ARGV parsing and suite\n"
"determination necessary for running one of the\n"
"TestRunners from the command line."
msgstr ""

msgid "Runs a Test::Unit::TestSuite and outputs XML."
msgstr ""

# Test::Unit::UI::XML::TestRunner#initialize
msgid ""
"Creates a new TestRunner for running the passed\n"
"suite. :output option specifies where runner\n"
"output should go to; defaults to STDOUT."
msgstr ""

# Test::Unit::Util::Observable
msgid ""
"This is a utility class that allows anything mixing\n"
"it in to notify a set of listeners about interesting\n"
"events."
msgstr ""

msgid "We use this for defaults since nil might mean something"
msgstr ""

# Test::Unit::Util::Observable#add_listener
msgid ""
"Adds the passed proc as a listener on the\n"
"channel indicated by channel_name. listener_key\n"
"is used to remove the listener later; if none is\n"
"specified, the proc itself is used."
msgstr ""

# Test::Unit::Util::Observable#add_listener
msgid ""
"Whatever is used as the listener_key is\n"
"returned, making it very easy to use the proc\n"
"itself as the listener_key:"
msgstr ""

# Test::Unit::Util::Observable#add_listener
msgid ""
"    listener = add_listener(\"Channel\") { ... }\n"
"    remove_listener(\"Channel\", listener)"
msgstr ""

# Test::Unit::Util::Observable#remove_listener
msgid ""
"Removes the listener indicated by listener_key\n"
"from the channel indicated by\n"
"channel_name. Returns the registered proc, or\n"
"nil if none was found."
msgstr ""

# Test::Unit::Util::Observable#notify_listeners
msgid ""
"Calls all the procs registered on the channel\n"
"indicated by channel_name. If value is\n"
"specified, it is passed in to the procs,\n"
"otherwise they are called with no arguments."
msgstr ""

# Test::Unit::Util::Observable#notify_listeners
msgid ""
"Perhaps this should be private? Would it ever\n"
"make sense for an external class to call this\n"
"method directly?"
msgstr ""

# Test::Unit::Util::Output#capture_output
msgid ""
"Returns output for standard output and standard\n"
"error as string."
msgstr ""

# Test::Unit::Util::Output#capture_output
msgid ""
"    capture_output do\n"
"      puts(\"stdout\")\n"
"      warn(\"stderr\")\n"
"    end # -> [\"stdout\n"
"\", \"stderr\n"
"\"]"
msgstr ""

# Test::Unit::Util::ProcWrapper
msgid ""
"Allows the storage of a Proc passed through '&' in a\n"
"hash."
msgstr ""

# Test::Unit::Util::ProcWrapper
msgid ""
"Note: this may be inefficient, since the hash being\n"
"used is not necessarily very good. In Observable,\n"
"efficiency is not too important, since the hash is\n"
"only accessed when adding and removing listeners,\n"
"not when notifying."
msgstr ""

msgid "Creates a new wrapper for a_proc."
msgstr ""

msgid "a new instance of ProcWrapper"
msgstr ""
test-unit-3.6.2/doc/templates/000077500000000000000000000000001456346657200162435ustar00rootroot00000000000000test-unit-3.6.2/doc/templates/footer.en.html.erb000066400000000000000000000033271456346657200216040ustar00rootroot00000000000000    

    

      
      
      
      






    

test-unit-3.6.2/doc/templates/footer.ja.html.erb000066400000000000000000000030741456346657200215730ustar00rootroot00000000000000    

    

      
      
      






    

test-unit-3.6.2/doc/templates/head.en.html.erb000066400000000000000000000004071456346657200212030ustar00rootroot00000000000000    
    
    
    <%= title %> - test-unit
test-unit-3.6.2/doc/templates/head.ja.html.erb000066400000000000000000000004071456346657200211730ustar00rootroot00000000000000    
    
    
    <%= title %> - test-unit
test-unit-3.6.2/doc/templates/header.en.html.erb000066400000000000000000000013641456346657200215350ustar00rootroot00000000000000

  

    
      <%= title %>
      -
      test-unit
    
  

  
  





test-unit-3.6.2/doc/templates/header.ja.html.erb000066400000000000000000000014771456346657200215320ustar00rootroot00000000000000

  

    
      <%= title %>
      -
      test-unit
    
  

  
  





test-unit-3.6.2/doc/text/000077500000000000000000000000001456346657200152315ustar00rootroot00000000000000test-unit-3.6.2/doc/text/getting-started.md000066400000000000000000000113441456346657200206630ustar00rootroot00000000000000## 1. First step of the `test-unit`

Let's getting start `test-unit`.

This document creates an example gem package called `sample` with the `test-unit` testing framework.

## 2. Install bundler and test-unit.

* First, install the `bundler` gem for generating gem template.
* Second, install the `test-unit` itself.

~~~
!!!plain
gem install bundler
gem install test-unit
~~~

The `gem list` command output installed packages.
You will find the following lines.

~~~
!!!plain
gem list
...
bundler (1.14.6)
...
test-unit (3.2.3)
~~~

## 3. Create gem template.

Next, create a gem template using `bundler` command.
This command generates package skeleton with a testing framework.
However, this command can't generate test templates for `test-unit`.

So, First create gem template with the `minitest` testing framework.
(It's similar to `unit-test`).
After that, replace some files for `test-unit`.

The `bundle gem -t minitest sample` command will generate the following files.

~~~
!!!plain
.
|-- Gemfile
|-- README.md
|-- Rakefile
|-- bin
|   |-- console
|   `-- setup
|-- lib
|   |-- sample
|   |   `-- version.rb
|   `-- sample.rb
|-- sample.gemspec  # <- Modify
`-- test
    |-- sample_test.rb # <- Modify
    `-- test_helper.rb # <- Modify
~~~

## 4. Edit files for `test-unit`

### 4.1. Edit gemspec

Edit `sample.gemspec` like the below.
Replace `minitest` line to `test-unit`.

Before

~~~
!!!ruby
  spec.add_development_dependency "minitest", "~> 5.0"
~~~

After

~~~
!!!ruby
  spec.add_development_dependency "test-unit", "~> 3.2.3"
~~~

### 4.2. Edit `test/test_helper.rb`

Next, edit the `test/test_helper.rb` file.

Before

~~~
!!!ruby
$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'sample'

require 'minitest/autorun' # <-- Modify this line.
~~~

After

~~~
!!!ruby
$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'sample'

require 'test/unit' # <-- After modification.
~~~

### 4.3 Rakefile (No edit)

This file doesn't need to modify.
The output is the below.

~~~
!!!ruby
require "bundler/gem_tasks"
require "rake/testtask"

Rake::TestTask.new(:test) do |t|
  t.libs << "test"
  t.libs << "lib"
  t.test_files = FileList['test/**/*_test.rb']
end

task :default => :test
~~~

### 4.4 Edit `test/sample_test.rb`

The bundler generate the file `test/sample_test.rb`.
This file originally templates for `minitest`.

Let's modify this file for `test-unit`

before

~~~
!!!ruby
require 'test_helper'

class SampleTest < Minitest::Test # <- Modify here
  def test_that_it_has_a_version_number
    refute_nil ::Sample::VERSION
  end

  def test_it_does_something_useful
    assert false
  end
end
~~~

After

~~~
!!!ruby
require 'test_helper'

class SampleTest < Test::Unit::TestCase # <- After modification
  def test_that_it_has_a_version_number
    refute_nil ::Sample::VERSION
  end

  def test_it_does_something_useful
    assert false
  end
end
~~~

## 5. Execute test.

The `rake test` command execute test scenarios in the `test` directory.
Now it tries to two tests. One will success the other one fails.

~~~
!!!plain
rake test
Loaded suite
/path/to/ruby/lib/ruby/gems/2.3.0/gems/rake-12.0.0/lib/rake/rake_test_loader
Started
F
================================================================================
Failure:  is not true.
test_it_does_something_useful(SampleTest)
/path/to/sample/test/sample_test.rb:9:in `test_it_does_something_useful'
      6:   end
      7:
      8:   def test_it_does_something_useful
  =>  9:     assert false
     10:   end
     11: end
================================================================================
.

Finished in 0.011521 seconds.
--------------------------------------------------------------------------------
2 tests, 2 assertions, 1 failures, 0 errors, 0 pendings, 0 omissions, 0 notifications
50% passed
--------------------------------------------------------------------------------
173.60 tests/s, 173.60 assertions/s
rake aborted!
Command failed with status (1)

Tasks: TOP => test
(See full trace by running task with --trace)
~~~

## 6. Create original tests.

Let's create your original tests with the following rules.

* Create a test file in the `test` directory.
* The file needs suffix  `xxx_test.rb`.
* You can put test file into the subdirectory like `test/sub`.

Example directory layout.

~~~
!!!plain
test
|-- sample_test.rb
|-- sub
|   `-- sample2_test.rb
`-- test_helper.rb
~~~

Example test file in the sub directory.

~~~
!!!ruby
require 'test_helper'

module Sub
  class Sample2Test < Test::Unit::TestCase
    def test_that_it_has_a_version_number
      refute_nil ::Sample::VERSION
    end

    def test_it_does_something_useful
      assert false
    end
  end
end
~~~

## 7. For more information

Let's read the official document.

* [test-unit](https://test-unit.github.io/index.html)
test-unit-3.6.2/doc/text/how-to.md000066400000000000000000000042611456346657200167730ustar00rootroot00000000000000# How To

## Run all tests

To make it easy to run all your tests, you can add a `run_test.rb` script
to your `test` directory. A simple example might look like:

    base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
    lib_dir  = File.join(base_dir, "lib")
    test_dir = File.join(base_dir, "test")

    $LOAD_PATH.unshift(lib_dir)

    require 'test/unit'

    exit Test::Unit::AutoRunner.run(true, test_dir)

Then it's easy to run tests via the command line with,

    $ ruby test/run_test.rb

## Change test runner via the command line

The output format can be changed via the command line with
the `--runner` option. Simply tack it to the end:

    ruby test/run_test.rb --runner tap


## Configure test-unit per-project

Test::Unit reads `test-unit.yml` or `.test-unit.yml` in the current working
directory as Test::Unit's configuration file. It can contain the following
settings:

* color scheme definitions
* test runner to be used
* test runner options
* test collector to be used

Except color scheme definitions, all of them can be specified by command
line option.

Here are sample color scheme definitions:

    color_schemes:
      inverted:
        success:
          name: red
          bold: true
        failure:
          name: green
          bold: true
      other_scheme:
        ...

Here are the syntax of color scheme definitions:

    color_schemes:
      SCHEME_NAME:
        EVENT_NAME:
          name: COLOR_NAME
          intensity: BOOLEAN
          bold: BOOLEAN
          italic: BOOLEAN
          underline: BOOLEAN
        ...
      ...

| Definition  | Description                  |
|-------------|------------------------------|
| SCHEME_NAME | the name of the color scheme |
| EVENT_NAME  | success, failure, pending, omission, notification, error |
| COLOR_NAME  | black, red, green, yellow, blue, magenta, cyan, white    |
| BOOLEAN     | true or false |

You can use the above 'inverted' color scheme with the following configuration:

    runner: console
    console_options:
      color_scheme: inverted
    color_schemes:
      inverted:
        success:
          name: red
          bold: true
        failure:
          name: green
          bold: true

test-unit-3.6.2/doc/text/news.md000066400000000000000000001377731456346657200165510ustar00rootroot00000000000000# News

## 3.6.2 - 2024-02-16 {#version-3-6-2}

### Improvements

  * UI: console: Add `--gc-stress` option that enables `GC.stress`
    only whie each test is running.

  * Added support for Ruby 3.4 style backtrace.
    [GH-237][https://github.com/test-unit/test-unit/issues/237]
    [Patch by Yusuke Endoh]

### Thanks

  * Yusuke Endoh

## 3.6.1 - 2023-06-25 {#version-3-6-1}

### Improvements

  * collector: load: Improved performance when a large number of test
    files exist.
    [GH-232][https://github.com/test-unit/test-unit/issues/232]
    [Patch by akira yamada]

### Thanks

  * akira yamada

## 3.6.0 - 2023-05-25 {#version-3-6-0}

### Improvements

  * UI: console: Use `--progress-style=fault-only` with non-tty output
    by default.

## 3.5.9 - 2023-05-25 {#version-3-5-9}

### Improvements

  * UI: console: Use `--progress-style=mark` with `--verbose=verbose`
    by default.

## 3.5.8 - 2023-05-12 {#version-3-5-8}

### Improvements

  * doc: Improved document for multi Ractor mode.
    [GH-226][https://github.com/test-unit/test-unit/issues/226]
    [Patch by Luke Gruber]

  * doc: Updated minitest's URL.
    [GH-228][https://github.com/test-unit/test-unit/issues/228]
    [Patch by Koichi ITO]

  * UI: console: Added `--progress-style` option.

  * UI: console: Compacted `--verbose=important-only` output..

  * UI: console: Changed the default output level to `important-only`
      on GitHub Actions.

### Thanks

  * Luke Gruber

  * Koichi ITO

## 3.5.7 - 2022-12-15 {#version-3-5-7}

### Improvements

  * [UI][console]: Changed to use color escape sequence for each line
    instead of each output that may consist with multiple lines.

## 3.5.6 - 2022-12-15 {#version-3-5-6}

### Improvements

  * [UI][console]: Enabled 256 colors output on GitHub Actions by default.

## 3.5.5 - 2022-10-04 {#version-3-5-5}

### Fixes

  * Suppressed a warning.
    [GitHub#219](https://github.com/test-unit/test-unit/issues/219)[Patch by Kenichi Kamiya]

### Thanks

  * Kenichi Kamiya

## 3.5.4 - 2022-10-04 {#version-3-5-4}

### Improvements

  * Don't raise an error on `Test::Unit::TestCase.clone`.
    [GitHub#210](https://github.com/test-unit/test-unit/issues/210)[Reported by David Marchaland]

  * Added support for `BigDeciaml` in `assert_in_delta` family.
    [GitHub#218](https://github.com/test-unit/test-unit/issues/218)[Patch by Kenta Murata]

### Thanks

  * David Marchaland

  * Kenta Murata

## 3.5.3 - 2021-12-20 {#version-3-5-3}

### Improvements

  * Made how to sub test case generation customizable.
    [GitHub#207](https://github.com/test-unit/test-unit/issues/207)[Patch by Akira Matsuda]

### Thanks

  * Akira Matsuda

## 3.5.2 - 2021-12-10 {#version-3-5-2}

### Improvements

  * Required `fileutils` lazy.
    [GitHub#206](https://github.com/test-unit/test-unit/issues/206)[Patch by David Rodríguez]

### Thanks

  * David Rodríguez

## 3.5.1 - 2021-11-08 {#version-3-5-1}

### Fixes

  * Fixed a bug that `keep: true` is ignored when data set is
    generated by block. [Reported by Kenta Murata]

### Thanks

  * Kenta Murata

## 3.5.0 - 2021-10-18 {#version-3-5-0}

### Fixes

  * Fixed a bug that `keep: true` is ignored when the last `data`
    doesn't have `keep: true`.

## 3.4.9 - 2021-10-18 {#version-3-4-9}

### Improvements

  * Added support for labeling each variable values by using `Hash`.

## 3.4.8 - 2021-10-11 {#version-3-4-8}

### Improvements

  * Added support for omitting Ractor tests on Ruby 2.7 or earlier
    automatically.

## 3.4.7 - 2021-09-14 {#version-3-4-7}

### Fixes

  * Suppressed a warning on Ruby 2.
    [GitHub#205](https://github.com/test-unit/test-unit/issues/205)[Patch by Kenichi Kamiya]

### Thanks

  * Kenichi Kamiya

## 3.4.6 - 2021-09-11 {#version-3-4-6}

### Improvements

  * Added support for tests that use Ractor. Use
    `Test::Unit::TestCase.ractor` to declare that these tests use
    Ractor.

  * Added `--debug-on-failure` option.

## 3.4.5 - 2021-09-04 {#version-3-4-5}

### Improvements

  * Added more metadata to gemspec.
    [GitHub#183](https://github.com/test-unit/test-unit/issues/183)[Patch by Kenichi Kamiya]

  * Removed needless files from gem.
    [GitHub#184](https://github.com/test-unit/test-unit/issues/184)[Patch by Kenichi Kamiya]

  * Updated documents.
    [GitHub#191](https://github.com/test-unit/test-unit/issues/191)[GitHub#192](https://github.com/test-unit/test-unit/issues/192)[GitHub#193](https://github.com/test-unit/test-unit/issues/193)[GitHub#199](https://github.com/test-unit/test-unit/issues/199)[GitHub#200](https://github.com/test-unit/test-unit/issues/200)
    [GitHub#201](https://github.com/test-unit/test-unit/issues/201)[Patch by Kenichi Kamiya]

  * Added `assert_nothing_leaked_memory`.

### Fixes

  * Fixed typos in documents.
    [GitHub#189](https://github.com/test-unit/test-unit/issues/189)[GitHub#190](https://github.com/test-unit/test-unit/issues/190)[GitHub#195](https://github.com/test-unit/test-unit/issues/195)[GitHub#197](https://github.com/test-unit/test-unit/issues/197)[Patch by Kenichi Kamiya]

### Thanks

  * Kenichi Kamiya

## 3.4.4 - 2021-06-04 {#version-3-4-4}

### Improvements

  * Renamed `assert_all?` to `assert_all`. `assert_all?` is deprecated
    but is available.

## 3.4.3 - 2021-06-04 {#version-3-4-3}

### Improvements

  * Stopped to change result value of `Test::Unit::TestCase#include`.

  * Added `assert_all?`.

  * Added support for `assert_raise_with_message`.

## 3.4.2 - 2021-05-30 {#version-3-4-2}

### Improvements

  * [UI][console]: Improved diff readability for no color
    case. Character based diff marks are always showed.

## 3.4.1 - 2021-04-19 {#version-3-4-1}

### Fixes

  * Fixed a bug that `setup`/`cleanup`/`teardown` with block may be
    overwritten by another `setup`/`cleanup`/`teardown` with
    block. It's caused only with Ruby 2.6 or earlier.
    [GitHub#179](https://github.com/test-unit/test-unit/issues/179)[Reported by akira yamada]

### Thanks

  * akira yamada

## 3.4.0 - 2021-01-30 {#version-3-4-0}

### Improvements

  * Enable deprecated warnings by default.

## 3.3.9 - 2020-12-29 {#version-3-3-9}

### Improvements

  * `assert_not_match`: Add support for `String` as pattern.
    [GitHub#178](https://github.com/test-unit/test-unit/issues/178)[Patch by David Rodríguez]

### Thanks

  * David Rodríguez

## 3.3.8 - 2020-12-25 {#version-3-3-8}

### Improvements

  * [UI][console]: Removed reverse mode because Ruby 3.0 reverts
    reverse backtrace.

## 3.3.7 - 2020-11-18 {#version-3-3-7}

### Improvements

  * Improved TruffleRuby support.
    [GitHub#171](https://github.com/test-unit/test-unit/issues/171)[Reported by Benoit Daloze]

  * Removed needless `to_sym`.
    [GitHub#177](https://github.com/test-unit/test-unit/issues/177)[Patch by icm7216]

  * `assert_raise`: Added backtrace for actual error.

  * Improved terminal color availability detection.
    [GitHub#175](https://github.com/test-unit/test-unit/issues/175)[Patch by nicholas a. evans]

  * Changed license to the new Ruby's.
    [GitHub#174](https://github.com/test-unit/test-unit/issues/174)

### Fixes

  * Fixed a typo in `--help` output:
    [GitHub#176](https://github.com/test-unit/test-unit/issues/176)[Patch by icm7216]

### Thanks

  * Benoit Daloze

  * icm7216

  * nicholas a. evans

## 3.3.6 - 2020-06-10 {#version-3-3-6}

### Improvements

  * `name`, `--ignore-name`:

     * Added support for regular expression options.

     * Added support for matching with class name in exact match mode.
       [Reported by Jun Aruga]

  * Updated ruby-talk mailing list information
    [GitHub#168](https://github.com/test-unit/test-unit/issues/168)[Patch by Chris Kampmeier]

### Thanks

  * Chris Kampmeier

  * Jun Aruga

## 3.3.5 - 2020-01-10 {#version-3-3-5}

### Improvements

  * Improved code snippet showing with different default external encoding.
    [GitHub#166](https://github.com/test-unit/test-unit/issues/166)[Patch by Yuta Iwama]

### Thanks

  * Yuta Iwama

## 3.3.4 - 2019-09-30 {#version-3-3-4}

### Improvements

  * Converted markup format to Markdown from RDoc.
    [GitHub#164](https://github.com/test-unit/test-unit/issues/164)[Patch by OGAWA KenIchi]

  * test: Stopped to depend on `Time#inspect` format.
    [GitHub#165](https://github.com/test-unit/test-unit/issues/165)[Reported by Benoit Daloze]

### Thanks

  * OGAWA KenIchi

  * Benoit Daloze

## 3.3.3 - 2019-05-10 {#version-3-3-3}

### Fixed

  * Fixed a bug that priority mode with test case name that uses
    special characters such as `?` can't be used on Windows.

## 3.3.2 - 2019-04-11 {#version-3-3-2}

### Fixes

  * Fixed a bug that `Test::Unit::Collector::Load` doesn't load test
    files under sub directories when these files have the same base
    name as test files in upper directories.
    [Reported by Kenta Murata]

### Thanks

  * Kenta Murata

## 3.3.1 - 2019-03-27 {#version-3-3-1}

### Improvements

  * Added support for `Test::Unit::AssertionFailedError#user_message`
    for not only `assert_equal` and `assert_raise` but also all
    assertions.
    [GitHub#162](https://github.com/test-unit/test-unit/issues/162)[Reported by xgraffm]

### Thanks

  * xgraffm

## 3.3.0 - 2019-01-23 {#version-3-3-0}

### Improvements

  * Added support for auto test run when all tests are defined in
    modules.

  * Added support for defining methods to test case class in multiple
    threads.
    [GitHub#159](https://github.com/test-unit/test-unit/issues/159)[Reported by Charles Oliver Nutter]

  * Suppressed warnings on Ruby 2.5.
    [GitHub#160](https://github.com/test-unit/test-unit/issues/160)[Reported by Daniel Berger]

  * Suppressed warnings on Ruby 2.7.

### Fixes

  * Fixed a code snippet fetch failure when source code isn't UTF-8
    and the default external encoding is set to not UTF-8.
    [GitHub#161](https://github.com/test-unit/test-unit/issues/161)[Reported by masa kunikata]

### Thanks

  * Charles Oliver Nutter

  * Daniel Berger

  * masa kunikata

## 3.2.9 - 2018-12-01 {#version-3-2-9}

### Improvements

  * Added support for data generation by method. `data_#{test_name}`
    is called to generate data for `test_name` test.

  * Added support for data matrix generation.

    Example:

    ```ruby
    data(:a, [0, 1, 2])
    data(:b, [:x, :y])
    def test_data(data)
    end
    ```

    This example generates the following data matrix:

      * label: `"a: 0, b: :x"`, data: `{a: 0, b: :x}`
      * label: `"a: 0, b: :y"`, data: `{a: 0, b: :y}`
      * label: `"a: 1, b: :x"`, data: `{a: 1, b: :x}`
      * label: `"a: 1, b: :y"`, data: `{a: 1, b: :y}`
      * label: `"a: 2, b: :x"`, data: `{a: 2, b: :x}`
      * label: `"a: 2, b: :y"`, data: `{a: 2, b: :y}`

  * Added `Test::Unit::TestCase#data` that returns the current data.

  * Added support for using test method that doesn't have no
    parameters as data driven test.

    Example:

    ```ruby
    data("label", :value)
    def test_data # Available since this release
      p data # :value
    end
    ```

  * Added support for `:keep` option to `Test::Unit::TestCase.data`.

  * Added support for `:group` option to
    `Test::Unit::TestCase.data`. It's useful to generate multiple data
    matrix groups.

    ```ruby
    # Group1
    data(:a, [0, 1, 2], group: :g1)
    data(:b, [:x, :y], group: :g1)
    # Group2
    data(:a, [:x, :y], group: :g2)
    data(:c, [-1, -2], group: :g2)
    def test_data(data)
    end
    ```

    This example generates the following data matrix:

      * label: `"group: :g1, a: 0, b: :x"`, data: `{a: 0, b: :x}`
      * label: `"group: :g1, a: 0, b: :y"`, data: `{a: 0, b: :y}`
      * label: `"group: :g1, a: 1, b: :x"`, data: `{a: 1, b: :x}`
      * label: `"group: :g1, a: 1, b: :y"`, data: `{a: 1, b: :y}`
      * label: `"group: :g1, a: 2, b: :x"`, data: `{a: 2, b: :x}`
      * label: `"group: :g1, a: 2, b: :y"`, data: `{a: 2, b: :y}`
      * label: `"group: :g2, a: :x, b: -1"`, data: `{a: :x, b: -1}`
      * label: `"group: :g2, a: :x, b: -2"`, data: `{a: :x, b: -2}`
      * label: `"group: :g2, a: :y, b: -1"`, data: `{a: :y, b: -1}`
      * label: `"group: :g2, a: :y, b: -2"`, data: `{a: :y, b: -2}`

## 3.2.8 - 2018-05-13 {#version-3-2-8}

### Improvements

  * [UI][console]: Changed to put code snippet before backtrace on
    reverse mode.

## 3.2.7 - 2017-12-12 {#version-3-2-7}

### Improvements

  * Added source code link to gemspec.
    [GitHub#157](https://github.com/test-unit/test-unit/issues/157)[Patch by Grey Baker]

  * Changed to use SVG image for badges in README.
    [GitHub#158](https://github.com/test-unit/test-unit/issues/158)[Patch by Olle Jonsson]

  * [UI][console]: Added `--reverse-output` option to output fault
    details in reverse like Ruby 2.5. It's enabled by default only for
    tty output.

### Fixes

  * Fixed a typo.
    [GitHub#156](https://github.com/test-unit/test-unit/issues/156)[Patch by masa kunikata]

  * [UI][console]: Fixed a bug that broken align in verbose mode.

### Thanks

  * masa kunikata

  * Grey Baker

  * Olle Jonsson

## 3.2.6 - 2017-09-21 {#version-3-2-6}

### Improvements

  * Changed test file require failure to error from omission.
    [GitHub#154](https://github.com/test-unit/test-unit/issues/154)[Patch by naofumi-fujii]

### Thanks

  * naofumi-fujii

## 3.2.5 - 2017-06-24 {#version-3-2-5}

### Improvements

  * Supported `--enable-frozen-string-literal` `ruby` option.
    [GitHub#149](https://github.com/test-unit/test-unit/issues/149)[Reported by Pat Allan]

### Thanks

  * Pat Allan

## 3.2.4 - 2017-05-23 {#version-3-2-4}

### Improvements

  * Updated tests for Ruby 2.4. [GitHUb#136][Patch by Kazuki Tsujimoto]

  * Supported power\_assert 1.0.0. [GitHub#137](https://github.com/test-unit/test-unit/issues/137)[Patch by Kazuki Tsujimoto]

  * Added the getting started document.
    [GitHub#139](https://github.com/test-unit/test-unit/issues/139)[GitHub#141](https://github.com/test-unit/test-unit/issues/141)[Patch by Hiroyuki Sato]

  * Added the document for `attribute`.
    [GitHub#143](https://github.com/test-unit/test-unit/issues/143)[Patch by Fumiaki MATSUSHIMA]

  * Improved a link for GitHub. [GitHub#144](https://github.com/test-unit/test-unit/issues/144)[Patch by rochefort]

  * Updated `.travis.yml`. [GitHub#145](https://github.com/test-unit/test-unit/issues/145)[Patch by Jun Aruga]

### Fixes

  * Fixed a contributor name. [GitHub#131](https://github.com/test-unit/test-unit/issues/131)[Patch by Akira Matsuda]

  * Fixed typos in document. [GitHub#132](https://github.com/test-unit/test-unit/issues/132)[Patch by Akira Matsuda]

  * Fixed typos in document. [GitHub#134](https://github.com/test-unit/test-unit/issues/134)[Patch by Yuji Yaginuma]

  * Fixed a bug that data label with "(" isn't supported.
    [GitHub#135](https://github.com/test-unit/test-unit/issues/135)[Reported by Kazuki Tsujimoto]

  * Fixed assertion message in English.
    [GitHub#133](https://github.com/test-unit/test-unit/issues/133)[Reported by Khalil Fazal]

  * Fixed a typo in typo fix. [GitHub#138](https://github.com/test-unit/test-unit/issues/138)[Patch by kami]

  * Fixed a bug that target location finder may return wrong
    location. [GitHub#146](https://github.com/test-unit/test-unit/issues/146)[Patch by Yuki Ito]

  * Fixed a bug that `--no-show-detail-immediately` raises an error.
    [GitHub#147](https://github.com/test-unit/test-unit/issues/147)[Reported by MSP-Greg]

### Thanks

  * Akira Matsuda

  * Yuji Yaginuma

  * Kazuki Tsujimoto

  * Khalil Fazal

  * kami

  * Hiroyuki Sato

  * Fumiaki MATSUSHIMA

  * rochefort

  * Jun Aruga

  * Yuki Ito

  * MSP-Greg

## 3.2.3 - 2016-11-25 {#version-3-2-3}

### Fixes

  * Fixed a bug that `--order` isn't applied.
    [GitHub#129](https://github.com/test-unit/test-unit/issues/129)[Reported by Vít Ondruch]

### Thanks

  * Vít Ondruch

## 3.2.2 - 2016-11-02 {#version-3-2-2}

### Improvements

  * Improved Travis CI configuration.
    [GitHub#123](https://github.com/test-unit/test-unit/issues/123)[Patch by Ryunosuke Sato]

  * Supported Java native exception.
    [GitHub#126](https://github.com/test-unit/test-unit/issues/126)[Reported by Bob Saveland]

### Fixes

  * doc: Fixed markup. [GitHub#127](https://github.com/test-unit/test-unit/issues/127)[Patch by Tomohiro Hashidate]

  * Fixed a bug that `--location=LINE` may not detect a test when
    fixtures are defined before any tests:

        1 class MyTestCase < Test::Unit::TestCase
        2   setup do
        3   end
        4
        5   test "xxx" do
        6   end
        7 end

    `--location=5` couldn't find the `xxx` test.

    [Reported by Ryota Sasabe]

### Thanks

  * Ryunosuke Sato

  * Tomohiro Hashidate

  * Bob Saveland

  * Ryota Sasabe

## 3.2.1 - 2016-07-19 {#version-3-2-1}

### Improvements

  * Clarified lib/test/unit/diff.rb license. It's a triple license of
    the Ruby license, PSF license and LGPLv2.1 or later.
    [Reported by Luisa Pace]

  * Reported norification when data driven test doesn't have
    parameter.
    [GitHub#122](https://github.com/test-unit/test-unit/issues/122)[Reported by Satoshi "Moris" Tagomori]

### Thanks

  * Luisa Pace

  * Satoshi "Moris" Tagomori

## 3.2.0 - 2016-06-12 {#version-3-2-0}

### Improvements

  * Supported rxvt family terminals as color available terminals.
    [GitHub#121](https://github.com/test-unit/test-unit/issues/121)[Reported by Ippei Kishida]

### Thanks

  * Ippei Kishida

## 3.1.9 - 2016-05-20 {#version-3-1-9}

### Fixes

  * Fixed conflict with test-unit-power_assert.
    [GitHub#120](https://github.com/test-unit/test-unit/issues/120)[Patch by Kazuki Tsujimoto]

  * Fixed a bug that path in `$LOAD_PATH` may be removed.

### Thanks

  * Kazuki Tsujimoto

## 3.1.8 - 2016-03-19 {#version-3-1-8}

### Improvements

  * Added `--stop-on-failure` command line option. With this option,
    running test suite is stopped immediately when one test is failed
    or an error is raised in one test.

## 3.1.7 - 2016-01-17 {#version-3-1-7}

### Fixes

 * Added a missing require.

## 3.1.6 - 2016-01-17 {#version-3-1-6}

It's a Ruby on Rails integration improvement release.

### Improvements

  * Filtered backtrace of power\_assert.
    [GitHub#114](https://github.com/test-unit/test-unit/issues/114)
  * Improved performance to retrieve test defined location.
  * Improved performance to run fixtures in a test.
  * Supported running a test by `yield` in `setup`:

    Before:

        def setup
          @file = File.open("x")
        end

        def teardown
          @file.close
        end

    After:

        def setup
          File.open("x") do |file|
            @file = file
            yield
          end
        end

  * Added `--default-test-path` option that specifies the default path
    that has tests.
  * Made auto runner registration more lazily. Auto runner isn't
    registered automatically until user defines a test. In the
    previous releases, auto runner is registered automatically when
    user defines a test case.
  * Supported specifying a test by location in command line. For
    example, the following command line runs a test that is defined in
    /tmp/test_a.rb at line 10:

        % ruby -r test-unit -e run_test /tmp/test_a.rb:10

### Fixes

  * Fixed a bug that test isn't ran. The test has the same name as
    data driven test that is defined in parent test case.
    [GitHub#115](https://github.com/test-unit/test-unit/issues/115)

## 3.1.5 - 2015-10-09 {#version-3-1-5}

It's a Rack integration improvement release.

### Improvements

  * Renamed experimental top-level `run` method to `run_test` method
    because `run` is conflicted with Rack.
    [GitHub#32](https://github.com/test-unit/test-unit/issues/32)[GitHub:basecamp/pow#303] [Reported by Yevhen Viktorov]

### Thanks

  * Yevhen Viktorov

## 3.1.4 - 2015-09-26 {#version-3-1-4}

It's a minor improvement release.

### Improvements

  * Updated sample code. [GitHub#109](https://github.com/test-unit/test-unit/issues/109)[Patch by takiy33]
  * Updated .travis.yml. [GitHub#110](https://github.com/test-unit/test-unit/issues/110)[Patch by takiy33]
  * document: Added table header in how to document.
    [GitHub#111](https://github.com/test-unit/test-unit/issues/111)[Patch by takiy33]
  * Removed duplicated code.
    [GitHub#112](https://github.com/test-unit/test-unit/issues/112)[Patch by takiy33]
  * Removed needless encoding conversion in fetching code snippet.
    [GitHub#113](https://github.com/test-unit/test-unit/issues/113)[Patch by NARUSE, Yui]

### Thanks

  * takiy33
  * NARUSE, Yui

## 3.1.3 - 2015-07-26 {#version-3-1-3}

It's a bug fix release.

### Improvements

  * Removed unused `TODO` file. [GitHub#108](https://github.com/test-unit/test-unit/issues/108)[Patch by takiy33]

### Fixes

  * `--location`: Fixed a bug that `--location LINE` doesn't work when
    test script is specified as relative path. [Reported by TOMITA Masahiro]

    The following doesn't work:

        % ruby ./test.rb --location 10

    The following works:

        % ruby test.rb --location 10

### Thanks

  * takiy33
  * TOMITA Masahiro

## 3.1.2 - 2015-06-09 {#version-3-1-2}

It's command line option improvements fix release.

### Improvements

  * `--location`: Made path match rule more strict.
    [Suggested by kimura wataru]
    * Before:
      * If test defined path ends with the specified path, the test is
        matched.
    * After:
      * If base name of test defined path equals to the specified
        path, the test is matched.
      * If relative path of test defined path equals to the specified
        path, the test is matched.
      * If the specified path is absolute path and test defined path
        equals to the specified path, the test is matched.
  * `--pattern`: If the option is specified, the default patterns
    aren't used. In the earlier versions, both the default patterns
    and the specified patterns are used.
    [Suggested by kimura wataru]

### Thanks

  * kimura wataru

## 3.1.1 - 2015-05-29 {#version-3-1-1}

It's a bug fix release.

### Fixes

  * Fixed a bug that `--location` detects tests not only in sub test
    case but also parent test case.
    [GitHub#105](https://github.com/test-unit/test-unit/issues/105)[Reported by wanabe]

### Thanks

  * wanabe

## 3.1.0 - 2015-05-28 {#version-3-1-0}

It's a bug fix release.

### Improvements

  * [ui][console] Removed needless new line.

### Fixes

  * Fixed a bug that priority mode can't be used on Windows.
    [GitHub#95](https://github.com/test-unit/test-unit/issues/95)[Reported by Daniel Berger]
  * Fixed a homepage URL RubyGems spec.
    [GitHub#96](https://github.com/test-unit/test-unit/issues/96)[Patch by Masayoshi Takahashi]
    supported.) [GitHub#89](https://github.com/test-unit/test-unit/issues/89)[Patch by Aaron Stone]
  * Fixed a bug that shutdown hook isn't called when pass throw
    exception such as `Interrupt` is raised.
    [GitHub#98](https://github.com/test-unit/test-unit/issues/98)[Reported by jeremiahishere.]
  * Fixed typos in documents.
    [GitHub#100](https://github.com/test-unit/test-unit/issues/100)[Reported by scivola]
    [GitHub#102](https://github.com/test-unit/test-unit/issues/102)[GitHub#103](https://github.com/test-unit/test-unit/issues/103)[Patch by Masafumi Yokoyama]
  * Fixed a bug that the same name test isn't executed in sub test case.
    [GitHub#104](https://github.com/test-unit/test-unit/issues/104)[Reported by wanabe]

### Thanks

  * Daniel Berger
  * Masayoshi Takahashi
  * jeremiahishere
  * scivola
  * Masafumi Yokoyama
  * wanabe

## 3.0.9 - 2014-12-31 {#version-3-0-9}

It's a release that improves colors.

### Improvements

  * Added a work around for Ruby 1.8. (Note: Ruby 1.8 isn't
    supported.) [GitHub#89](https://github.com/test-unit/test-unit/issues/89)[Patch by Aaron Stone]
  * Supported colorized output on Windows.
    [GitHub#90](https://github.com/test-unit/test-unit/issues/90)[Patch by usa]
  * Improved colorized output.
    http://www.a-k-r.org/d/2014-12.html#a2014_12_27_1
    [Suggested by Tanaka Akira]

### Thanks

  * Aaron Stone
  * usa
  * Tanaka Akira

## 3.0.8 - 2014-12-12 {#version-3-0-8}

It's a release that supports Ruby 2.2.0 preview2.

### Improvements

  * Added a link for YARD in README.
    [GitHub:test-unit.github.io#2][Reported by sunnyone]
  * Added description about "/PATTERN/" style value in auto runner usage.
    [GitHub#86](https://github.com/test-unit/test-unit/issues/86)[Suggested by sunnyone]
  * Supported Ruby 2.2.0 preview2 in `assert_throw` and
    `assert_nothing_thrown`.

### Fixes

  * Fixed a bug that error report is failed when source encoding and
    locale encoding are different.
    [GitHub#87](https://github.com/test-unit/test-unit/issues/87)[Reported by scivola]

### Thanks

  * sunnyone
  * scivola

## 3.0.7 - 2014-11-14 {#version-3-0-7}

It's a minor update release.

### Fixes

  * Fixed a bug that teardown blocks aren't called with sub class to
    parent class order.
    [GitHub#85](https://github.com/test-unit/test-unit/issues/85)[Reported by TOMITA Masahiro]

### Thanks

  * TOMITA Masahiro

## 3.0.6 - 2014-11-09 {#version-3-0-6}

It's a minor update release.

### Improvements

  * Improved code snippet location.
    [GitHub#84](https://github.com/test-unit/test-unit/issues/84)[Patch by Yuki Kurihara]

### Thanks

  * Yuki Kurihara

## 3.0.5 - 2014-11-08 {#version-3-0-5}

It's a minor update release.

### Fixes

  * Fixed a bug that startup/shutdown of parent test case isn't called
    when the test case includes one or more modules.
    [GitHub#83](https://github.com/test-unit/test-unit/issues/83)[Reported by Chadderton Odwazny]

### Thanks

  * Chadderton Odwazny

## 3.0.4 - 2014-11-01 {#version-3-0-4}

It's a minor update release.

### Improvements

  * Stopped to remove JRuby and Rubinius internal backtrace entries from
    backtrace on failure/error.
    [GitHub#82](https://github.com/test-unit/test-unit/issues/82)[Patch by Charles Oliver Nutter]

### Thanks

  * Charles Oliver Nutter

## 3.0.3 - 2014-10-29 {#version-3-0-3}

It's a minor update release.

### Improvements

  * Improved `Test::Unit::TestCase.test` performance.
    100 times faster.
  * Supported `Proc` for user message.
    [Sugested by Nobuyoshi Nakada]

### Fixes

  * Fixed markup in document.
    [GitHub#81](https://github.com/test-unit/test-unit/issues/81)[Patch by Masafumi Yokoyama]

### Thanks

  * Masafumi Yokoyama
  * Nobuyoshi Nakada

## 3.0.2 - 2014-10-15 {#version-3-0-2}

It's a minor update release.

### Improvements

  * Supported broken `==` implementation.
    `==` implementation should be fixed but it's not work of test-unit. :<
    [GitHub#71](https://github.com/test-unit/test-unit/issues/71)[Reported by Emily]
  * [UI][console]: Accepted no message failure.
    [GitHub#66](https://github.com/test-unit/test-unit/issues/66)[Reported by Brian Tatnall]
  * Updated gem description.
    [GitHub#74](https://github.com/test-unit/test-unit/issues/74)[Patch by Vít Ondruch]
  * Updated GPL text.
    [GitHub#78](https://github.com/test-unit/test-unit/issues/78)[Patch by Vít Ondruch]

### Fixes

  * Removed needless executable bit from README file.
    [GitHub#79](https://github.com/test-unit/test-unit/issues/79)[Patch by Vít Ondruch]

### Thanks

  * Emily
  * Brian Tatnall
  * Vít Ondruch

## 3.0.1 - 2014-08-05 {#version-3-0-1}

It's a minor update release.

### Improvements

  * Improved Ruby 1.8.7 support. Note that we don't support Ruby 1.8.7
    actively. We just support if its support is painless.
    [GitHub#71](https://github.com/test-unit/test-unit/issues/71)[Patch by estolfo]

### Thanks

  * estolfo

## 3.0.0 - 2014-08-03 {#version-3-0-0}

It's Power Assert supported release!

### Improvements

  * Improved Rubinius support. [Ryo Onodera]
  * Updated RR repository link. [GitHub#56](https://github.com/test-unit/test-unit/issues/56)[Patch by Kenichi Kamiya]
  * Added some minitest compatible assertions. We don't recommend
    using these assertions. They are just for migrating from minitest.
    [GitHub#57](https://github.com/test-unit/test-unit/issues/57)[Patch by Karol Bucek]
    * {Test::Unit::Assertions#refute}
    * {Test::Unit::Assertions#refute_predicate}
    * {Test::Unit::Assertions#refute_empty}
    * {Test::Unit::Assertions#assert_not_includes}
    * {Test::Unit::Assertions#refute_includes}
    * {Test::Unit::Assertions#assert_not_instance_of}
    * {Test::Unit::Assertions#refute_instance_of}
    * {Test::Unit::Assertions#assert_not_kind_of}
    * {Test::Unit::Assertions#refute_kind_of}
    * {Test::Unit::Assertions#assert_not_operator}
    * {Test::Unit::Assertions#refute_operator}
  * Improved code readability. [Suggested by Kenichi Kamiya]
  * Made license field in RubyGems parseable.
    [GitHub#60](https://github.com/test-unit/test-unit/issues/60)[Patch by Michael Grosser]
  * Improved test case match feature by `--testcase` and `--ignore-testcase`
    options. They also checks parent class names.
  * Made inspected representation of Numeric objects especially
    BigDecimal more readable. [GitHub#64](https://github.com/test-unit/test-unit/issues/64)[Reported by Byron Appelt]
  * Added badges for Traivs CI and RubyGems.
    [GitHub#65](https://github.com/test-unit/test-unit/issues/65)[Patch by Byron Appelt]
  * Supported Power Assert. You can use Power Assert with
    {Test::Unit::Assertions#assert} with block. See method document
    for details. We recommend using Power Assert for predicate method
    checks. For example, we recommend Power Assert rather than
    {Test::Unit::Assertions#assert_true},
    {Test::Unit::Assertions#assert_predicate} and so on. We don't
    recommend using Power Assert for equality check assertion.
    {Test::Unit::Assertions#assert_equal} should be used for the case.
    [Kazuki Tsujimoto]

### Fixes

  * Fixed a bug that test case defined by block has wrong location.
    [GitHub#58](https://github.com/test-unit/test-unit/issues/58)[Patch by Narihiro Nakamura]
  * Fixed a bug that test methods defined in included modules in
    super-class are also collected.
    [GitHub#62](https://github.com/test-unit/test-unit/issues/62)[GitHub#63](https://github.com/test-unit/test-unit/issues/63)[Patch by Karol Bucek]

### Thanks

  * Ryo Onodera
  * Kenichi Kamiya
  * Karol Bucek
  * Narihiro Nakamura
  * Michael Grosser
  * Byron Appelt
  * Kazuki Tsujimoto

## 2.5.5 - 2013-05-18 {#version-2-5-5}

It's Ruby 2.0.0 supported release!

### Improvements

  * Supported Ruby 2.0.0. [GitHub#54](https://github.com/test-unit/test-unit/issues/54) [Reported by mtasaka]
  * Accepted screen-256color TERM as 256 colors available environment.
    [GitHub#55](https://github.com/test-unit/test-unit/issues/55) [Reported by Tom Miller]

### Fixes

  * Fixed a typo in document.
    [GitHub#53](https://github.com/test-unit/test-unit/issues/53) [Patch by Baptiste Fontaine]
  * Fixed a bug in {Test::Unit::Assertions#assert_in_epsilon}. It doesn't work
    as expected if expected value is negative value.
    [Ruby Bug #8317] [Reported by Nobuhiro IMAI]

### Thanks

  * Baptiste Fontaine
  * mtasaka
  * Tom Miller
  * Nobuhiro IMAI

## 2.5.4 - 2013-01-23 {#version-2-5-4}

It's a bug fix release.

### Improvements

  * Added documents for data driven test functionality.
  * Added TSV support for data driven test functionality.
  * Support tag inspection on JRuby.

### Fixes

  * Fixed a bug. It is too slow to filter tests when there are many
    tests. [GitHub#46](https://github.com/test-unit/test-unit/issues/46)
  * Accept anonymous test suite.
    [GitHub:#49] [Reported by Matthew Rudy Jacobs]

### Thanks

  * Matthew Rudy Jacobs

## 2.5.3 - 2012-11-28 {#version-2-5-3}

It's a release for minitest compatibility and bug fix.

### Improvements

  * Supported diff in invalid encoding.
  * Added some assersion methods just for minitest compatibility.
    Added methods are assert_includes(), refute_*() and refute().
    If you are test-unit user, please don't use them.
    [GitHub#40](https://github.com/test-unit/test-unit/issues/40) [Suggested by Michael Grosser]
  * Added --attribute option to select target tests by attribute.
    [test-unit-users-en:00098] [Suggested by Piotr Nestorow]

### Fixes

  * Allowed use of test for inheritance in ActionController::TestCase.
    [GitHub#42](https://github.com/test-unit/test-unit/issues/42) [Patch by David Rasch]
  * Ensured evaluating at_exit block in top level.
    In IRB context, exit() specifies irb_exit().
    [test-unit-users-en:00089] [Reported by Daniel Berger]
  * Fixed a bug that decoration style description is ignored.
    "decoration style description" are using description method
    above "def test_name" or with Symbol specifying test_name.
    [GitHub#45](https://github.com/test-unit/test-unit/issues/45) [Reported by Piotr Nestorow]

### Thanks

  * Michael Grosser
  * David Rasch
  * Daniel Berger
  * Piotr Nestorow

## 2.5.2 - 2012-08-29 {#version-2-5-2}

It's an improvement release for tmtms. `--location` is a similar
feature to `--line_number` in RSpec. `sub_test_case` is a similar
feature to `context` in shoulda-context and RSpec.

### Improvements

  * Cleaned up tests.
    [GitHub#34](https://github.com/test-unit/test-unit/issues/34) [Patch by Michael Grosser]
  * Added missing background color for 8 color environment.
  * Added workaround for NetBeans.
    [GitHub#38](https://github.com/test-unit/test-unit/issues/38) [Reported by Marc Cooper]
  * Added `--location` command line option that selects target tests
    by test defined location.
  * Created sub test suite for each subclassed test case.
  * [ui][console] Supported nested test suites.
  * Added {Test::Unit.at_start} and {Test::Unit.at_exit} hooks that
    are run before/after all tests are run.
    [Good hook name is suggested by kdmsnr]
  * Improved code snippet target on failure. Test method is always used
    for code snippet target.
    [GitHub#39](https://github.com/test-unit/test-unit/issues/39) [Suggested by Michael Grosser]
  * Added {Test::Unit::TestCase.sub_test_case} that creates sub test case.
    The sub test case name isn't limited Ruby's constant name rule. You can
    specify the sub test case name in free form.

### Thanks

  * Michael Grosser
  * Marc Cooper
  * kdmsnr

## 2.5.1 - 2012-07-05 {#version-2-5-1}

It's a bug fix release.

### Improvements

  * Supported installing from GitHub.
    [GitHub#29](https://github.com/test-unit/test-unit/issues/29) [Suggested by Michael Grosser]
  * Supported ActiveSupport::TestCase.
    [GitHub#30](https://github.com/test-unit/test-unit/issues/30) [Reported by Michael Grosser]
  * [ui][console] Improved multiline falut message display.

### Fixes

  * [ui][console] Fixed a bug that expected and actual values are
    empty.
    [GitHub#31](https://github.com/test-unit/test-unit/issues/31)[GitHub#33](https://github.com/test-unit/test-unit/issues/33)
    [Reported by Kendall Buchanan][Reported by Mathieu Martin]
    [Hinted by Michael Grosser]
  * Fixed a bug that .gemspec can't be loaded on LANG=C.
    [RubyForge#29595] [Reported by Jean-Denis Koeck]

### Thanks

  * Michael Grosser
  * Kendall Buchanan
  * Mathieu Martin
  * Jean-Denis Koeck

## 2.5.0 - 2012-06-06 {#version-2-5-0}

It's a bug fix release.

### Fixes

  * Fixed a backward incompatibility of `TestUnitMediator#run_suite`
    introduced in 2.4.9.
    [GitHub#28](https://github.com/test-unit/test-unit/issues/28) [Reported by Vladislav Rassokhin]

### Thanks

  * Vladislav Rassokhin

## 2.4.9 - 2012-06-03 {#version-2-4-9}

It's a bug fix release.

### Improvements

  * `Test::Unit.run?` ->
    `Test::Unit::AutoRunner.need_auto_run?`. `Test::Unit.run?` is marked
    as deprecated but it is still available.
  * [experimental] Added top level "run" method for `"ruby -rtest-unit -e
    run test/test_*.rb"`. Is this API OK or dirty?
  * Made failure output more readable on no color mode.
  * Supported showing ASCII-8BIT diff in failure message.
  * [ui][console] Supported `ENV["TERM"] == "xterm-256color"` as color
    available terminal.
    [GitHub#26](https://github.com/test-unit/test-unit/issues/26) [Reported by Michael Grosser]
  * [ui][console] Supported "-256color" suffix `ENV["TERM"]` terminal
    as 256 color supported terminal.

### Fixes

  * Fixed a bug that `--workdir` doesn't work.
  * Consumed processed command line parameters in `ARGV` as `--help`
    says.
    [RubyForge#29554] [Reported by Bob Saveland]
  * Added missing `require "test/unit/diff"`.
    [GitHub#25](https://github.com/test-unit/test-unit/issues/25) [Reported by Stephan Kulow]

### Thanks

  * Bob Saveland
  * Stephan Kulow
  * Michael Grosser

## 2.4.8 - 2012-3-6 {#version-2-4-8}

It's a bug fix release.

### Improvements

  * Delayed at_exit registration until Test::Unit is used.
    [GitHub:#21] [Reported by Jason Lunn]
  * Added workaround for test-spec.
    [GitHub:#22] [Reported by Cédric Boutillier]

### Fixes

  * Fixed an error on code snippet display on JRuby.
    [GitHub:#19][GitHub:#20]
    [Reported by Jørgen P. Tjernø][Patch by Junegunn Choi]

### Thanks

  * Jørgen P. Tjernø
  * Junegunn Choi
  * Jason Lunn

## 2.4.7 - 2012-2-10 {#version-2-4-7}

It's a code snippet improvement release.

### Improvements

  * Supported code snippet display on all faults.

## 2.4.6 - 2012-2-9 {#version-2-4-6}

It's a TAP runner separated release.

### Improvements

  * Moved TAP runner to test-unit-runner-tap gem from test-unit gem.
  * Supported code snippet display on failure.

## 2.4.5 - 2012-1-16 {#version-2-4-5}

It's a failure message readability improvement release.

### Improvements

  * Removed needless information from exception inspected
    text on failure. It's for easy to read.
  * Supported custom inspector.

## 2.4.4 - 2012-1-2 {#version-2-4-4}

It's a Rails integration improved release.

### Improvements

  * [ui][console] Don't break progress display when a test is failed.
  * [ui][console] Added markers betwen a failure detail
    message in progress to improve visibility.
  * [travis] Dropped Ruby 1.8.6 as a test target. [GitHub:#13]
    [Patch by Josh Kalderimis]
  * Supported expected value == 0 case in assert_in_epsilon. [RubyForge#29485]
    [Reported by Syver Enstad]
  * Supported a block style setup/teardown/cleanup.

### Thanks

  * Josh Kalderimis
  * Syver Enstad

## 2.4.3 - 2011-12-11 {#version-2-4-3}

### Improvements

  * Improved SimpleCov integration by stopping to modify
    `ARGV` in auto runner. [GitHub:#12]
    [Reported by Nikos Dimitrakopoulos]
  * Improved JRuby integration by removing JRuby internal backtrace.

### Thanks

  * Nikos Dimitrakopoulos

## 2.4.2 - 2011-11-26 {#version-2-4-2}

### Improvements

  * `--name` supported data label.

## 2.4.1 - 2011-11-09

### Improvements

  * Accepted AssertionMessage as assertion's user message.
    It is used in assert_select in actionpack.
    [Reported by David Heath]

### Fixes

  * Fixed test failure on LANG=C. #11 [Reported by boutil]
  * Suppress warnings on Ruby 1.9.2.

### Thanks

  * boutil
  * David Heath

## 2.4.0 - 2011-09-18

### Improvements

  * Supported Travis CI. #5 [Suggested by James Mead]
  * Added Gemfile. #6 [Suggested by James Mead]
  * [ui][console] Supported notification in show-detail-immediately.
  * [ui][console] enable --show-detail-immediately by default.
  * [ui] Added --max-diff-target-string-size option.
  * [ui][console] Supported 256 colors.

### Fixes

  * Added missing fixture file. #7 [Reported by grafi-tt]
  * [ui][console] Added missing the last newline for progress level.
  * Supported correct backtrace for redefined notification.
  * Don't handle Timeout::Error as pass through exception on Ruby 1.8. #8
    [Reported by Marc Seeger (Acquia)]

### Thanks

  * James Mead
  * grafi-tt
  * Marc Seeger (Acquia)

## 2.3.2 - 2011-08-15

A bug fix release.

### Improvements

  * [ui][console] Added some newlines to improve readability.

### Fixes

  * [ui][console] Worked --verbose again.
  * Re-supported Ruby 1.8.6. [Reported by James Mead]

### Thanks

  * James Mead

## 2.3.1 - 2011-08-06 {#version-2-3-1}

Output improvement release!

### Improvements

  * [ui][console] Outputs omissions and notifications in short.
  * [ui][console] Added "important-only" verbose level.
  * Intelligence diff supports recursive references.
  * [rubyforge #29325] Supported Ruby Enterprise Edition.
    [Reported by Hans de Graaff]
  * [rubyforge #29326] Supported JRuby.
    [Reported by Hans de Graaff]
  * Added --show-detail-immediately option that shows
    fault details when a fault is occurred.

### Fixes

  * [pull request #1] Fixed a problem that load collector
    can't load a test file on Ruby 1.9. [Patch by grafi-tt]
  * [issue #3] Fixed a problem that implicit method name
    override by declarative style test definition.
    [Reported by Jeremy Stephens]

### Thanks

  * grafi-tt
  * Jeremy Stephens
  * Hans de Graaff

## 2.3.0 / 2011-04-17

* 13 enhancements
  * improve Hash key sorting for diff.
  * [#28928] support any characters in declarative style description.
    [Daniel Berger]
  * add Error#location and make #backtrace deprecated.
  * make TestCase#passed? public.
  * add result finished and pass assertion notifications.
  * add TestSuite#passed? public.
  * add XML test runner.
  * add --output-file-descriptor option.
  * measure elapsed time for each test.
  * add --collector option.
  * support test driven test.
    [Haruka Yoshihara]
  * add cleanup hook it runs between after test and before teardown.
  * support recursive collection sort for diff.

* Thanks
  * Daniel Berger
  * Haruka Yoshihara

## 2.2.0 / 2011-02-14

* 22 enhancements
  * [#28808] accept String as delta for assert_in_delta.
    [Daniel Berger]
  * [test-unit-users-en:00035] make GC-able finished tests.
    [Daniel Berger]
  * use also COLUMNS environment variable to guess terminal width.
  * make delta for assert_in_delta optional.
    [Nobuyoshi Nakada]
  * add assert_not_respond_to.
    [Nobuyoshi Nakada]
  * add assert_not_match. assert_no_match is deprecated.
    [Nobuyoshi Nakada]
  * add assert_not_in_delta.
    [Nobuyoshi Nakada]
  * add assert_in_epsilon.
    [Nobuyoshi Nakada]
  * add assert_not_in_epsilon.
    [Nobuyoshi Nakada]
  * add assert_include.
    [Nobuyoshi Nakada]
  * add assert_not_include.
    [Nobuyoshi Nakada]
  * add assert_empty.
    [Nobuyoshi Nakada]
  * add assert_not_empty.
    [Nobuyoshi Nakada]
  * notify require failed paths.
  * validate message value for assert.
  * show throughputs at the last.
  * support not ASCII compatible string diff.
  * support colorized diff on encoding different string.
  * normalize entry order of Hash for readable diff.
  * add --ignore-name option.
  * add --ignore-testcase option.
  * add assert_not_send.

* Thanks
  * Daniel Berger
  * Nobuyoshi Nakada

## 2.1.2 / 2010-11-25

* 1 enhancement
  * support auto runner prepare hook.

## 2.1.1 / 2010-07-29

* 1 bug fix
  * [test-unit-users-en:00026] re-work tap runner.
    [Daniel Berger]

* Thanks
  * Daniel Berger

=== 2.1.0 / 2010-07-17

* 1 bug fix
  * [#28267] global config file ignored
    [Daniel Berger]

* Thanks
  * Daniel Berger

## 2.0.8 / 2010-06-02

* 5 major enchancements
  * collect *_test.rb and *-test.rb files as test files.
  * [#28181] improve assert_in_delta message.
    [Suggested by David MARCHALAND]
  * show string encoding in assert_equal failure message if
    they are different.
  * change default color scheme:
    * success: green back + white
    * failure: red back + white
  * add capture_output.

* 2 bug fixes
  * fix a bug that console runner on verbose mode causes an
    error for long test name (>= 61).
  * [#28093] Autorunner ignores all files in a directory named test by default
    [Reported by Florian Frank]

* Thanks
  * Florian Frank
  * David MARCHALAND

## 2.0.7 / 2010-03-09

* 4 major enhancements
  * detect redefined test methods.
  * [INTERFACE IMCOMPATIBLE] multiple --name and --testcase
    options narrow down targets instead of adding targets.
  * [#27764] accept custom test_order for each test case.
    [Suggested by David MARCHALAND]
  * [#27790] ignore omitted tests from 'n% passed' report.
    [Suggested by Daniel Berger]

* 2 minor enchancements
  * [#27832] ignore .git directory. [Suggested by Daniel Berger]
  * [#27792] require 'fileutils' and 'tmpdir' lazily for non-priority
    mode users. [Suggested by David MARCHALAND]

* 2 bug fixes
  * [#27892] modify processed arguments array destructively.
    [Reported by Bob Saveland]
  * work without HOME environment variable.
    [Reported by Champak Ch]

* Thanks
  * David MARCHALAND
  * Daniel Berger
  * Bob Saveland
  * Champak Ch

## 2.0.6 / 2010-01-09

* 3 major enhancements
  * [#27380] Declarative syntax? [Daniel Berger]
    support declarative syntax:

      test "test description in natural language" do
         ...
      end
  * support test description:
      description "test description in natural language"
      def test_my_test
         ...
      end
  * make max diff target string size customizable by
    TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE environment variable.

* 2 bug fixes
  * [#27374] omit_if unexpected behavior [David MARCHALAND]
  * fix a bug that tests in sub directories aren't load with --basedir.
    [Daniel Berger]

* Thanks
  * David MARCHALAND
  * Daniel Berger

## 2.0.5 / 2009-10-18

* 1 bug fixes
  * [#27314] fix diff may raise an exception. [Erik Hollensbe]

* Thanks
  * Erik Hollensbe

## 2.0.4 / 2009-10-17

* 4 major enhancements
  * use ~/.test-unit.yml as global configuration file.
  * add TAP runner. (--runner tap)
  * support colorized diff:
    https://test-unit.github.io/color-diff.png
  * add Test::Unit::AutoRunner.default_runner= to specify default test runner.

* 4 minor enhancements
  * improve verbose mode output format. (use indent)
  * support `NOT_PASS_THROUGH_EXCEPTIONS`.
  * support arguments option in `#{runner}_options`.
  * TC_ -> Test in sample test case name.

* 1 bug fixes
  * [#27195] test-unit-2.0.3 + ruby-1.9.1 cannot properly test
    DelegateClass subclasses [Mike Pomraning]

* Thanks
  * Mike Pomraning

## 2.0.3 / 2009-07-19

* 6 major enhancements
  * add assert_predicate.
  * add assert_not_predicate.
  * [#24210] assert_kind_of supports an array of classes or modules.
    [Daniel Berger]
  * assert_instance_of supports an array of classes or modules.
  * add --default-priority option.
  * [#26627] add --order option. [Daniel Berger]

* 4 minor enhancements
  * use yellow foreground + black background for error.
  * don't show diff for long string.
  * accept "*term-color" TERM environment as colorizable terminal.
    (e.g. Apple's Terminal)
  * [#26268] add a workaround for test-spec's after_all. [Angelo Lakra]

* 1 bug fix
  * [#23586] re-support ruby 1.9.1. [Diego Pettenò]

* Thanks
  * Diego Pettenò
  * Daniel Berger
  * Angelo Lakra

## 2.0.2 / 2008-12-21

* 2 major enhancements

  * re-support ruby 1.8.5.
  * improve exception object comparison.

* 3 bug fixes

  * [#22723]: collector fails on anonymous classes
  * [#22986]: Test names with '?' blow up on Windows
  * [#22988]: don't create .test-result on non-priority mode.

* Thanks

  * Erik Hollensbe
  * Daniel Berger
  * Bill Lear

## 2.0.1 / 2008-11-09

* 19 major enhancements

  * support ruby 1.9.1.
  * add run_test method to be extensible.
  * improve priority-mode auto off.
  * improve startup/shutdown RDoc. [Daniel Berger]
  * add assert_compare. [#20851] [Designing Patterns]
  * add assert_fail_assertion. [#20851] [Designing Patterns]
  * add assert_raise_message. [#20851] [Designing Patterns]
  * support folded diff.
  * add assert_raise_kind_of. [Daniel Berger]
  * ingore inherited test for nested test case.
  * add assert_const_defined.
  * add assert_not_const_defined.
  * support assert_raise with an exception object.
  * support assert_raise with no arguments that asserts any
    exception is raised. [#22602] [Daniel Berger]
  * support folded dot progress.
  * add --progress-row-max option.
  * support color scheme customize.
  * support configuration file. (YAML)
  * recognize test-XXX.rb files as test files not only test_XXX.rb

* Thanks

  * Daniel Berger
  * Designing Patterns

## 2.0.0 / 2008-06-18

* 15 major enhancements

  * support startup/shutdown. (test case level setup/teardown)
  * support multiple setup/teardown.
  * support pending.
  * support omission.
  * support notification.
  * support colorize.
  * support diff.
  * support test attribute.
  * add assert_boolean.
  * add assert_true.
  * add assert_false.
  * add --priority-mode option.
  * don't use ObjectSpace to collect test cases.
  * make more customizable. (additional options, exception handling and so on)
  * improve Emacs integration.

* 4 major changes

  * remove GTK+1 support.
  * split GTK+ runner as another gem.
  * split FOX runner as another gem.
  * split Tk runner as another gem.

## 1.2.3 / 2008-02-25

* 1 major enhancement

  * Birthday (as a gem)!
test-unit-3.6.2/lib/000077500000000000000000000000001456346657200142465ustar00rootroot00000000000000test-unit-3.6.2/lib/test-unit.rb000066400000000000000000000007111456346657200165260ustar00rootroot00000000000000# Copyright (C) 2012-2015  Kouhei Sutou 

require "test/unit/warning"

module Test
  module Unit
    autoload :TestCase, "test/unit/testcase"
    autoload :AutoRunner, "test/unit/autorunner"
  end
end

unless respond_to?(:run_test, true)
  # experimental. It is for "ruby -rtest-unit -e run_test test/test_*.rb".
  # Is this API OK or dirty?
  def run_test
    self.class.send(:undef_method, :run_test)
    require "test/unit"
  end
end
test-unit-3.6.2/lib/test/000077500000000000000000000000001456346657200152255ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit.rb000066400000000000000000000402201456346657200165270ustar00rootroot00000000000000require "test/unit/warning"

require 'test/unit/testcase'
require 'test/unit/autorunner'

module Test # :nodoc:
  #
  # # Test::Unit - Ruby Unit Testing Framework
  #
  # ## Introduction
  #
  # Unit testing is making waves all over the place, largely due to the
  # fact that it is a core practice of XP. While XP is great, unit testing
  # has been around for a long time and has always been a good idea. One
  # of the keys to good unit testing, though, is not just writing tests,
  # but having tests. What's the difference? Well, if you just _write_ a
  # test and throw it away, you have no guarantee that something won't
  # change later which breaks your code. If, on the other hand, you _have_
  # tests (obviously you have to write them first), and run them as often
  # as possible, you slowly build up a wall of things that cannot break
  # without you immediately knowing about it. This is when unit testing
  # hits its peak usefulness.
  #
  # Enter Test::Unit, a framework for unit testing in Ruby, helping you to
  # design, debug and evaluate your code by making it easy to write and
  # have tests for it.
  #
  #
  # ## Notes
  #
  # Test::Unit has grown out of and superceded Lapidary.
  #
  #
  # ## Feedback
  #
  # I like (and do my best to practice) XP, so I value early releases,
  # user feedback, and clean, simple, expressive code. There is always
  # room for improvement in everything I do, and Test::Unit is no
  # exception. Please, let me know what you think of Test::Unit as it
  # stands, and what you'd like to see expanded/changed/improved/etc. If
  # you find a bug, let me know ASAP; one good way to let me know what the
  # bug is is to submit a new test that catches it :-) Also, I'd love to
  # hear about any successes you have with Test::Unit, and any
  # documentation you might add will be greatly appreciated. My contact
  # info is below.
  #
  #
  # ## Contact Information
  #
  #   * [GitHub issues on
  #     test-unit/test-unit](https://github.com/test-unit/test-unit/issues):
  #     If you have any issues, please report them to here.
  #
  #   * [GitHub pull requests on
  #     test-unit/test-unit](https://github.com/test-unit/test-unit/pulls):
  #     If you have any patches, please report them to here.
  #
  #   * [ruby-talk mailing
  #     list](https://www.ruby-lang.org/en/community/mailing-lists/):
  #     If you have any questions, you can ask them here.
  #
  #
  # ## Credits
  #
  # I'd like to thank...
  #
  # Matz, for a great language!
  #
  # Masaki Suketa, for his work on RubyUnit, which filled a vital need in
  # the Ruby world for a very long time. I'm also grateful for his help in
  # polishing Test::Unit and getting the RubyUnit compatibility layer
  # right. His graciousness in allowing Test::Unit to supercede RubyUnit
  # continues to be a challenge to me to be more willing to defer my own
  # rights.
  #
  # Ken McKinlay, for his interest and work on unit testing, and for his
  # willingness to dialog about it. He was also a great help in pointing
  # out some of the holes in the RubyUnit compatibility layer.
  #
  # Dave Thomas, for the original idea that led to the extremely simple
  # "require 'test/unit'", plus his code to improve it even more by
  # allowing the selection of tests from the command-line. Also, without
  # RDoc, the documentation for Test::Unit would stink a lot more than it
  # does now.
  #
  # Everyone who's helped out with bug reports, feature ideas,
  # encouragement to continue, etc. It's a real privilege to be a part of
  # the Ruby community.
  #
  # The guys at RoleModel Software, for putting up with me repeating, "But
  # this would be so much easier in Ruby!" whenever we're coding in Java.
  #
  # My Creator, for giving me life, and giving it more abundantly.
  #
  #
  # ## License
  #
  # Test::Unit is copyright (c) 2000-2003 Nathaniel Talbott. It is free
  # software, and is distributed under the Ruby license. See the COPYING
  # file.
  #
  # Exception: lib/test/unit/diff.rb is copyright (c)
  # 2008-2010 Kouhei Sutou and 2001-2008 Python Software
  # Foundation. It is free software, and is distributed
  # under the Ruby license and/or the PSF license. See the
  # COPYING file and PSFL file.
  #
  # ## Warranty
  #
  # This software is provided "as is" and without any express or
  # implied warranties, including, without limitation, the implied
  # warranties of merchantibility and fitness for a particular
  # purpose.
  #
  #
  # ## Author
  #
  # Nathaniel Talbott.
  # Copyright (c) 2000-2003, Nathaniel Talbott
  #
  # ----
  #
  # # Usage
  #
  # The general idea behind unit testing is that you write a _test_
  # _method_ that makes certain _assertions_ about your code, working
  # against a _test_ _fixture_. A bunch of these _test_ _methods_ are
  # bundled up into a _test_ _suite_ and can be run any time the
  # developer wants. The results of a run are gathered in a _test_
  # _result_ and displayed to the user through some UI. So, lets break
  # this down and see how Test::Unit provides each of these necessary
  # pieces.
  #
  #
  # ## Assertions
  #
  # These are the heart of the framework. Think of an assertion as a
  # statement of expected outcome, i.e. "I assert that x should be equal
  # to y". If, when the assertion is executed, it turns out to be
  # correct, nothing happens, and life is good. If, on the other hand,
  # your assertion turns out to be false, an error is propagated with
  # pertinent information so that you can go back and make your
  # assertion succeed, and, once again, life is good. For an explanation
  # of the current assertions, see Test::Unit::Assertions.
  #
  #
  # ## Test Method & Test Fixture
  #
  # Obviously, these assertions have to be called within a context that
  # knows about them and can do something meaningful with their
  # pass/fail value. Also, it's handy to collect a bunch of related
  # tests, each test represented by a method, into a common test class
  # that knows how to run them. The tests will be in a separate class
  # from the code they're testing for a couple of reasons. First of all,
  # it allows your code to stay uncluttered with test code, making it
  # easier to maintain. Second, it allows the tests to be stripped out
  # for deployment, since they're really there for you, the developer,
  # and your users don't need them. Third, and most importantly, it
  # allows you to set up a common test fixture for your tests to run
  # against.
  #
  # What's a test fixture? Well, tests do not live in a vacuum; rather,
  # they're run against the code they are testing. Often, a collection
  # of tests will run against a common set of data, also called a
  # fixture. If they're all bundled into the same test class, they can
  # all share the setting up and tearing down of that data, eliminating
  # unnecessary duplication and making it much easier to add related
  # tests.
  #
  # Test::Unit::TestCase wraps up a collection of test methods together
  # and allows you to easily set up and tear down the same test fixture
  # for each test. This is done by overriding #setup and/or #teardown,
  # which will be called before and after each test method that is
  # run. The TestCase also knows how to collect the results of your
  # assertions into a Test::Unit::TestResult, which can then be reported
  # back to you... but I'm getting ahead of myself. To write a test,
  # follow these steps:
  #
  # * Make sure Test::Unit is in your library path.
  # * require 'test/unit' in your test script.
  # * Create a class that subclasses Test::Unit::TestCase.
  # * Add a method that begins with "test" to your class.
  # * Make assertions in your test method.
  # * Optionally define #setup and/or #teardown to set up and/or tear
  #   down your common test fixture.
  # * You can now run your test as you would any other Ruby
  #   script... try it and see!
  #
  # A really simple test might look like this (#setup and #teardown are
  # commented out to indicate that they are completely optional):
  #
  #     require 'test/unit'
  #     
  #     class MyTest < Test::Unit::TestCase
  #       # def setup
  #       # end
  #     
  #       # def teardown
  #       # end
  #     
  #       def test_fail
  #         assert(false, 'Assertion was false.')
  #       end
  #     end
  #
  #
  # ## Test Runners
  #
  # So, now you have this great test class, but you still
  # need a way to run it and view any failures that occur
  # during the run. There are some test runner; console test
  # runner, GTK+ test runner and so on. The console test
  # runner is automatically invoked for you if you require
  # 'test/unit' and simply run the file. To use another
  # runner simply set default test runner ID to
  # Test::Unit::AutoRunner:
  #
  #     require 'test/unit'
  #     Test::Unit::AutoRunner.default_runner = "gtk2"
  #
  # ## Test Suite
  #
  # As more and more unit tests accumulate for a given project, it
  # becomes a real drag running them one at a time, and it also
  # introduces the potential to overlook a failing test because you
  # forget to run it. Suddenly it becomes very handy that the
  # TestRunners can take any object that returns a Test::Unit::TestSuite
  # in response to a suite method. The TestSuite can, in turn, contain
  # other TestSuites or individual tests (typically created by a
  # TestCase). In other words, you can easily wrap up a group of
  # TestCases and TestSuites.
  #
  # Test::Unit does a little bit more for you, by wrapping
  # these up automatically when you require
  # 'test/unit'. What does this mean? It means you could
  # write the above test case like this instead:
  #
  #     require 'test/unit'
  #     require 'test_myfirsttests'
  #     require 'test_moretestsbyme'
  #     require 'test_anothersetoftests'
  #
  # Test::Unit is smart enough to find all the test cases existing in
  # the ObjectSpace and wrap them up into a suite for you. It then runs
  # the dynamic suite using the console TestRunner.
  #
  #
  # ## Configuration file
  #
  # Test::Unit reads 'test-unit.yml' in the current working
  # directory as Test::Unit's configuration file. It can
  # contain the following configurations:
  #
  # * color scheme definitions
  # * test runner to be used
  # * test runner options
  # * test collector to be used
  #
  # Except color scheme definitions, all of them are
  # specified by command line option.
  #
  # Here are sample color scheme definitions:
  #
  #     color_schemes:
  #       inverted:
  #         success:
  #           name: red
  #           bold: true
  #         failure:
  #           name: green
  #           bold: true
  #       other_scheme:
  #         ...
  #
  # Here are the syntax of color scheme definitions:
  #
  #     color_schemes:
  #       SCHEME_NAME:
  #         EVENT_NAME:
  #           name: COLOR_NAME
  #           intensity: BOOLEAN
  #           bold: BOOLEAN
  #           italic: BOOLEAN
  #           underline: BOOLEAN
  #         ...
  #       ...
  #
  # SCHEME_NAME
  # : the name of the color scheme
  #
  # EVENT_NAME
  # : one of [success, failure, pending, omission, notification, error]
  #
  # COLOR_NAME
  # : one of [black, red, green, yellow, blue, magenta, cyan, white]
  #
  # BOOLEAN
  # : true or false
  #
  # You can use the above 'inverted' color scheme with the
  # following configuration:
  #
  #     runner: console
  #     console_options:
  #       color_scheme: inverted
  #     color_schemes:
  #       inverted:
  #         success:
  #           name: red
  #           bold: true
  #         failure:
  #           name: green
  #           bold: true
  #
  # ## Questions?
  #
  # I'd really like to get feedback from all levels of Ruby
  # practitioners about typos, grammatical errors, unclear statements,
  # missing points, etc., in this document (or any other).
  #

  module Unit
    class << self
      # Set true when Test::Unit has run.  If set to true Test::Unit
      # will not automatically run at exit.
      #
      # @deprecated Use {Test::Unit::AutoRunner.need_auto_run=} instead.
      def run=(have_run)
        AutoRunner.need_auto_run = (not have_run)
      end

      # Already tests have run?
      #
      # @deprecated Use {Test::Unit::AutoRunner.need_auto_run?} instead.
      def run?
        not AutoRunner.need_auto_run?
      end

      # @api private
      @@at_start_hooks = []

      # Register a hook that is run before running tests.
      # To register multiple hooks, call this method multiple times.
      #
      # Here is an example test case:
      #
      #     Test::Unit.at_start do
      #       # ...
      #     end
      #
      #     class TestMyClass1 < Test::Unit::TestCase
      #       class << self
      #         def startup
      #           # ...
      #         end
      #       end
      #
      #       def setup
      #         # ...
      #       end
      #
      #       def test_my_class1
      #         # ...
      #       end
      #
      #       def test_my_class2
      #         # ...
      #       end
      #     end
      #
      #     class TestMyClass2 < Test::Unit::TestCase
      #       class << self
      #         def startup
      #           # ...
      #         end
      #       end
      #
      #       def setup
      #         # ...
      #       end
      #
      #       def test_my_class1
      #         # ...
      #       end
      #
      #       def test_my_class2
      #         # ...
      #       end
      #     end
      #
      # Here is a call order:
      #
      # * at_start
      # * TestMyClass1.startup
      # * TestMyClass1#setup
      # * TestMyClass1#test_my_class1
      # * TestMyClass1#setup
      # * TestMyClass1#test_my_class2
      # * TestMyClass2#setup
      # * TestMyClass2#test_my_class1
      # * TestMyClass2#setup
      # * TestMyClass2#test_my_class2
      #
      # @example
      #   Test::Unit.at_start do
      #     puts "Start!"
      #   end
      #
      # @yield A block that is run before running tests.
      # @yieldreturn [void]
      # @return [void]
      #
      # @since 2.5.2
      def at_start(&hook)
        @@at_start_hooks << hook
      end

      # @api private
      def run_at_start_hooks
        @@at_start_hooks.each do |hook|
          hook.call
        end
      end

      # @api private
      @@at_exit_hooks = []

      # Register a hook that is run after running tests.
      # To register multiple hooks, call this method multiple times.
      #
      # Here is an example test case:
      #
      #     Test::Unit.at_exit do
      #       # ...
      #     end
      #
      #     class TestMyClass1 < Test::Unit::TestCase
      #       class << self
      #         def shutdown
      #           # ...
      #         end
      #       end
      #
      #       def teardown
      #         # ...
      #       end
      #
      #       def test_my_class1
      #         # ...
      #       end
      #
      #       def test_my_class2
      #         # ...
      #       end
      #     end
      #
      #     class TestMyClass2 < Test::Unit::TestCase
      #       class << self
      #         def shutdown
      #           # ...
      #         end
      #       end
      #
      #       def teardown
      #         # ...
      #       end
      #
      #       def test_my_class1
      #         # ...
      #       end
      #
      #       def test_my_class2
      #         # ...
      #       end
      #     end
      #
      # Here is a call order:
      #
      # * TestMyClass1#test_my_class1
      # * TestMyClass1#teardown
      # * TestMyClass1#test_my_class2
      # * TestMyClass1#teardown
      # * TestMyClass1.shutdown
      # * TestMyClass2#test_my_class1
      # * TestMyClass2#teardown
      # * TestMyClass2#test_my_class2
      # * TestMyClass2#teardown
      # * TestMyClass2.shutdown
      # * at_exit
      #
      # @example
      #   Test::Unit.at_exit do
      #     puts "Exit!"
      #   end
      #
      # @yield A block that is run after running tests.
      # @yieldreturn [void]
      # @return [void]
      #
      # @since 2.5.2
      def at_exit(&hook)
        @@at_exit_hooks << hook
      end

      # @api private
      def run_at_exit_hooks
        @@at_exit_hooks.each do |hook|
          hook.call
        end
      end
    end
  end
end

Module.new do
  at_exit do
    if $!.nil? and Test::Unit::AutoRunner.need_auto_run?
      exit Test::Unit::AutoRunner.run
    end
  end
end
test-unit-3.6.2/lib/test/unit/000077500000000000000000000000001456346657200162045ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/assertion-failed-error.rb000066400000000000000000000030121456346657200231050ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

module Test
  module Unit

    # Thrown by Test::Unit::Assertions when an assertion fails.
    class AssertionFailedError < StandardError
      @debug_on_failure = false
      class << self
        def debug_on_failure=(boolean)
          @debug_on_failure = boolean
        end

        def debug_on_failure?
          @debug_on_failure
        end
      end

      attr_accessor :expected, :actual, :user_message
      attr_accessor :inspected_expected, :inspected_actual
      def initialize(message=nil, options=nil)
        options ||= {}
        @expected = options[:expected]
        @actual = options[:actual]
        @inspected_expected = options[:inspected_expected]
        @inspected_actual = options[:inspected_actual]
        @user_message = options[:user_message]
        super(message)
        debug_on_failure
      end

      private
      def debug_on_failure
        return unless self.class.debug_on_failure?

        begin
          require "debug"
        rescue LoadError
          return
        end

        return unless binding.respond_to?(:break)

        frames = caller(0)
        pre = nil
        Util::BacktraceFilter.filter_backtrace(frames).each do |location|
          frame_index = frames.index(location)
          next if frame_index.nil?
          pre = "frame #{frame_index}"
          break
        end
        binding.break(pre: pre)
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/assertions.rb000066400000000000000000002555051456346657200207370ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
#             Copyright (c) 2009-2013 Kouhei Sutou. All rights reserved.
# License:: Ruby license.

require 'test/unit/assertion-failed-error'
require 'test/unit/util/backtracefilter'
require 'test/unit/util/memory-usage'
require 'test/unit/util/method-owner-finder'
require 'test/unit/diff'

begin
  require 'power_assert'
rescue LoadError, SyntaxError
end

module Test
  module Unit

    ##
    # Test::Unit::Assertions contains the standard Test::Unit assertions.
    # Assertions is included in Test::Unit::TestCase.
    #
    # To include it in your own code and use its functionality, you simply
    # need to rescue Test::Unit::AssertionFailedError. Additionally you may
    # override add_assertion to get notified whenever an assertion is made.
    #
    # Notes:
    #
    # * The message to each assertion, if given, will be propagated with the
    #   failure.
    # * It is easy to add your own assertions based on assert_block().
    #
    # @example Example Custom Assertion
    #
    #   def deny(boolean, message=nil)
    #     message = build_message(message, ' is not false or nil.', boolean)
    #     assert_block(message) do
    #       not boolean
    #     end
    #   end

    module Assertions

      ##
      # The assertion upon which all other assertions are based. Passes if the
      # block yields not false nor nil.
      #
      # @example
      #   assert_block "Couldn't do the thing" do
      #     do_the_thing
      #   end
      def assert_block(message="assert_block failed.")
        _wrap_assertion do
          if (! yield)
            options = {}
            if message.respond_to?(:user_message)
              options[:user_message] = message.user_message
            end
            raise AssertionFailedError.new(message.to_s, options)
          end
        end
      end

      # @private
      NOT_SPECIFIED = Object.new

      # @overload assert(object, message=nil)
      #
      #   Asserts that `object` is not false nor nil.
      #
      #   Normally, you don't need to use this assertion. Use more
      #   specific assertions such as #assert_equal and
      #   #assert_include.
      #
      #   @example Pass patterns
      #     assert(true)               # => pass
      #     assert([1, 2].include?(1)) # => pass
      #
      #   @example Failure patterns
      #     assert(nil)                # => failure
      #     assert(false)              # => failure
      #     assert([1, 2].include?(5)) # => failure
      #
      #   @param [Object] object The check target.
      #   @param [String] message The additional user message. It is
      #     showed when the assertion is failed.
      #   @return [void]
      #
      # @overload assert(message=nil) {}
      #
      #   Asserts that the givens block returns not false nor nil.
      #
      #   This style uses Power Assert. It means that you can see each
      #   object values in method chains on failure. See the following
      #   example about Power Assert.
      #
      #   @example Power Assert
      #     coins = [1, 5, 50]
      #     target_coin = 10
      #     assert do
      #       coins.include?(target_coin)
      #     end
      #     # =>
      #     #  coins.include?(target_coin)
      #     #  |     |        |
      #     #  |     |        10
      #     #  |     false
      #     #  [1, 5, 50]
      #
      #   We recommend you to use Power Assert for predicate method
      #   checks rather than existing assertions such as
      #   #assert_include and #assert_predicate. Power Assert shows
      #   useful message for debugging.
      #
      #   We don't recommend you use Power Assert for equality
      #   check. You should use #assert_equal for the case. Because
      #   #assert_equal shows more useful message for debugging.
      #
      #   @example Pass patterns
      #     assert {true}               # => pass
      #     assert {[1, 2].include?(1)} # => pass
      #
      #   @example Failure patterns
      #     assert {nil}                # => failure
      #     assert {false}              # => failure
      #     assert {[1, 2].include?(5)} # => failure
      #
      #   @param [String] message The additional user message. It is
      #     showed when the assertion is failed.
      #   @yield [] Given no parameters to the block.
      #   @yieldreturn [Object] The checked object.
      #   @return [void]
      def assert(object=NOT_SPECIFIED, message=nil, &block)
        _wrap_assertion do
          have_object = !NOT_SPECIFIED.equal?(object)
          if block
            message = object if have_object
            if defined?(PowerAssert)
              PowerAssert.start(block, :assertion_method => __callee__) do |pa|
                pa_message = AssertionMessage.delayed_literal(&pa.message_proc)
                assertion_message = build_message(message, "?", pa_message)
                assert_block(assertion_message) do
                  pa.yield
                end
              end
            else
              assert(yield, message)
            end
          else
            unless have_object
              raise ArgumentError, "wrong number of arguments (0 for 1..2)"
            end
            assertion_message = nil
            case message
            when nil, String, Proc
            when AssertionMessage
              assertion_message = message
            else
              error_message = "assertion message must be String, Proc or "
              error_message += "#{AssertionMessage}: "
              error_message += "<#{message.inspect}>(<#{message.class}>)"
              raise ArgumentError, error_message, filter_backtrace(caller)
            end
            assertion_message ||= build_message(message,
                                                " is not true.",
                                                object)
            assert_block(assertion_message) do
              object
            end
          end
        end
      end

      # Asserts that `object` is false or nil.
      #
      # @note Just for minitest compatibility. :<
      #
      # @param [Object] object The object to be asserted.
      # @return [void]
      #
      # @example Pass patterns
      #   refute(false)    # => pass
      #   refute(nil)      # => pass
      #
      # @example Failure patterns
      #   refute(true)     # => failure
      #   refute("string") # => failure
      #
      # @since 2.5.3
      def refute(object, message=nil)
        _wrap_assertion do
          assertion_message = nil
          case message
          when nil, String, Proc
          when AssertionMessage
            assertion_message = message
          else
            error_message = "assertion message must be String, Proc or "
            error_message += "#{AssertionMessage}: "
            error_message += "<#{message.inspect}>(<#{message.class}>)"
            raise ArgumentError, error_message, filter_backtrace(caller)
          end
          assert_block("refute should not be called with a block.") do
            !block_given?
          end
          assertion_message ||= build_message(message,
                                              " is neither nil or false.",
                                              object)
          assert_block(assertion_message) do
            not object
          end
        end
      end

      ##
      # Passes if `expected` == `actual`.
      #
      # Note that the ordering of arguments is important, since a helpful
      # error message is generated when this one fails that tells you the
      # values of expected and actual.
      #
      # @example
      #   assert_equal 'MY STRING', 'my string'.upcase
      def assert_equal(expected, actual, message=nil)
        diff = AssertionMessage.delayed_diff(expected, actual)
        if expected.respond_to?(:encoding) and
            actual.respond_to?(:encoding) and
            expected.encoding != actual.encoding
          format = <(?) expected but was
(?).?
EOT
          full_message = build_message(message, format,
                                       expected, expected.encoding.name,
                                       actual, actual.encoding.name,
                                       diff)
        else
          full_message = build_message(message, < expected but was
.?
EOT
        end
        begin
          assert_block(full_message) { expected == actual }
        rescue AssertionFailedError => failure
          _set_failed_information(failure, expected, actual)
          raise failure # For JRuby. :<
        end
      end

      ##
      # Passes if the block raises one of the expected
      # exceptions. When an expected exception is an Exception
      # object, passes if expected_exception == actual_exception.
      #
      # @example
      #   assert_raise(RuntimeError, LoadError) do
      #     raise 'Boom!!!'
      #   end # -> pass
      #
      #   assert_raise do
      #     raise Exception, 'Any exception should be raised!!!'
      #   end # -> pass
      #
      #   assert_raise(RuntimeError.new("XXX")) {raise "XXX"} # -> pass
      #   assert_raise(MyError.new("XXX"))      {raise "XXX"} # -> fail
      #   assert_raise(RuntimeError.new("ZZZ")) {raise "XXX"} # -> fail
      def assert_raise(*args, &block)
        assert_expected_exception = Proc.new do |*_args|
          message, assert_exception_helper, actual_exception = _args
          expected = assert_exception_helper.expected_exceptions
          diff = AssertionMessage.delayed_diff(expected, actual_exception)
          full_message = build_message(message,
                                       " exception expected but was\n.?",
                                       expected, actual_exception, diff)
          begin
            assert_block(full_message) do
              expected == [] or
                assert_exception_helper.expected?(actual_exception)
            end
          rescue AssertionFailedError => failure
            _set_failed_information(failure, expected, actual_exception)
            raise failure # For JRuby. :<
          end
        end
        _assert_raise(assert_expected_exception, *args, &block)
      end

      # Just for minitest compatibility. :<
      alias_method :assert_raises, :assert_raise

      # Passes if the block raises `expected_exception` with
      # `expected_message`. `expected_message` can be a `String` or
      # `Regexp`.
      #
      # @example Pass pattern: String
      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
      #     raise "Boom!!!"
      #   end # -> pass
      #
      # @example Pass pattern: Regexp
      #   assert_raise_with_message(RuntimeError, /!!!/) do
      #     raise "Boom!!!"
      #   end # -> pass
      #
      # @example Failure pattern: Exception class isn't matched
      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
      #     raise ArgumentError, "Boom!!!"
      #   end # -> failure
      #
      # @example Failure pattern: Exception message isn't matched
      #   assert_raise_with_message(RuntimeError, "Boom!!!") do
      #     raise "Hello"
      #   end # -> failure
      #
      # @since 3.4.3
      def assert_raise_with_message(expected_exception_class,
                                    expected_message,
                                    message=nil,
                                    &block)
        assert_expected_exception = Proc.new do |*_args|
          _message, assert_exception_helper, actual_exception = _args
          diff = AssertionMessage.delayed_diff([
                                                 expected_exception_class,
                                                 expected_message,
                                               ],
                                               [
                                                 actual_exception.class,
                                                 actual_exception.message,
                                               ])
          full_message = build_message(message,
                                       "() exception expected but was\n" +
                                       "().?",
                                       expected_exception_class,
                                       expected_message,
                                       actual_exception.class,
                                       actual_exception.message,
                                       diff)
          begin
            assert_block(full_message) do
              assert_exception_helper.expected?(actual_exception) and
                expected_message === actual_exception.message
            end
          rescue AssertionFailedError => failure
            _set_failed_information(failure,
                                    expected_exception_class,
                                    actual_exception)
            raise failure # For JRuby. :<
          end
          actual_exception
        end
        args = [expected_exception_class]
        args << message if message
        _assert_raise(assert_expected_exception, *args, &block)
      end

      ##
      # Passes if the block raises one of the given
      # exceptions or sub exceptions of the given exceptions.
      #
      # @example
      #   assert_raise_kind_of(SystemCallError) do
      #     raise Errno::EACCES
      #   end
      def assert_raise_kind_of(*args, &block)
        assert_expected_exception = Proc.new do |*_args|
          message, assert_exception_helper, actual_exception = _args
          expected = assert_exception_helper.expected_exceptions
          full_message = build_message(message,
                                       " family exception expected " +
                                       "but was\n.",
                                       expected, actual_exception)
          assert_block(full_message) do
            assert_exception_helper.expected?(actual_exception, :kind_of?)
          end
        end
        _assert_raise(assert_expected_exception, *args, &block)
      end


      ##
      # Passes if `object`.instance_of?(`klass`). When `klass` is
      # an array of classes, it passes if any class
      # satisfies +object.instance_of?(class).
      #
      # @example
      #   assert_instance_of(String, 'foo')            # -> pass
      #   assert_instance_of([Fixnum, NilClass], 100)  # -> pass
      #   assert_instance_of([Numeric, NilClass], 100) # -> fail
      def assert_instance_of(klass, object, message=nil)
        _wrap_assertion do
          if klass.is_a?(Array)
            klasses = klass
          else
            klasses = [klass]
          end
          assert_block("The first parameter to assert_instance_of should be " +
                       "a Class or an Array of Class.") do
            klasses.all? {|k| k.is_a?(Class)}
          end
          klass_message = AssertionMessage.maybe_container(klass) do |value|
            "<#{value}>"
          end
          full_message = build_message(message, < was expected to be instance_of\\?
? but was
.
EOT
          assert_block(full_message) do
            klasses.any? {|k| object.instance_of?(k)}
          end
        end
      end

      ##
      # Passes if `object`.instance_of?(`klass`) does not hold.
      # When `klass` is an array of classes, it passes if no class
      # satisfies +object.instance_of?(class).
      #
      # @example
      #   assert_not_instance_of(String, 100)                # -> pass
      #   assert_not_instance_of([Fixnum, NilClass], '100')  # -> pass
      #   assert_not_instance_of([Numeric, NilClass], 100)   # -> fail
      #
      # @since 3.0.0
      def assert_not_instance_of(klass, object, message=nil)
        _wrap_assertion do
          if klass.is_a?(Array)
            klasses = klass
          else
            klasses = [klass]
          end
          assert_block("The first parameter to assert_not_instance_of should be " +
                       "a Class or an Array of Class.") do
            klasses.all? {|k| k.is_a?(Class)}
          end
          klass_message = AssertionMessage.maybe_container(klass) do |value|
            "<#{value}>"
          end
          full_message = build_message(message,
                                       " was expected to not be instance_of\\?\n" +
                                       "? but was.",
                                       object,
                                       klass_message)
          assert_block(full_message) do
            klasses.none? {|k| object.instance_of?(k)}
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_instance_of, :assert_not_instance_of

      ##
      # Passes if `object`.nil?.
      #
      # @example
      #   assert_nil [1, 2].uniq!
      def assert_nil(object, message=nil)
        full_message = build_message(message, < was expected to be nil.
EOT
        assert_block(full_message) { object.nil? }
      end

      ##
      # Passes if `object`.kind_of?(`klass`). When `klass` is
      # an array of classes or modules, it passes if any
      # class or module satisfies +object.kind_of?(class_or_module).
      #
      # @example
      #   assert_kind_of(Object, 'foo')                # -> pass
      #   assert_kind_of([Fixnum, NilClass], 100)      # -> pass
      #   assert_kind_of([Fixnum, NilClass], "string") # -> fail
      def assert_kind_of(klass, object, message=nil)
        _wrap_assertion do
          if klass.is_a?(Array)
            klasses = klass
          else
            klasses = [klass]
          end
          assert_block("The first parameter to assert_kind_of should be " +
                       "a kind_of Module or an Array of a kind_of Module.") do
            klasses.all? {|k| k.kind_of?(Module)}
          end
          klass_message = AssertionMessage.maybe_container(klass) do |value|
            "<#{value}>"
          end
          full_message = build_message(message,
                                       " was expected to be kind_of\\?\n" +
                                       "? but was\n" +
                                       ".",
                                       object,
                                       klass_message,
                                       object.class)
          assert_block(full_message) do
            klasses.any? {|k| object.kind_of?(k)}
          end
        end
      end

      ##
      # Passes if `object`.kind_of?(`klass`) does not hold.
      # When `klass` is an array of classes or modules, it passes only if all
      # classes (and modules) do not satisfy +object.kind_of?(class_or_module).
      #
      # @example
      #   assert_not_kind_of(Fixnum, 'foo')           # -> pass
      #   assert_not_kind_of([Fixnum, NilClass], '0') # -> pass
      #   assert_not_kind_of([Fixnum, NilClass], 100) # -> fail
      #
      # @since 3.0.0
      def assert_not_kind_of(klass, object, message=nil)
        _wrap_assertion do
          if klass.is_a?(Array)
            klasses = klass
          else
            klasses = [klass]
          end
          assert_block("The first parameter to assert_not_kind_of should be " +
                       "a kind_of Module or an Array of a kind_of Module.") do
            klasses.all? {|k| k.kind_of?(Module)}
          end
          klass_message = AssertionMessage.maybe_container(klass) do |value|
            "<#{value}>"
          end
          full_message = build_message(message,
                                       " was expected to not be kind_of\\?\n" +
                                       "? but was.",
                                       object,
                                       klass_message)
          assert_block(full_message) do
            klasses.none? {|k| object.kind_of?(k)}
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_kind_of, :assert_not_kind_of

      ##
      # Passes if `object` .respond_to? `method`
      #
      # @example
      #   assert_respond_to 'bugbear', :slice
      def assert_respond_to(object, method, message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       ".kind_of\\?(Symbol) or\n" +
                                       ".respond_to\\?(:to_str) expected",
                                       method, method)
          assert_block(full_message) do
            method.kind_of?(Symbol) or method.respond_to?(:to_str)
          end
          full_message = build_message(message,
                                       ".respond_to\\?(?) expected\n" +
                                       "(Class: )",
                                       object, method, object.class)
          assert_block(full_message) {object.respond_to?(method)}
        end
      end

      ##
      # Passes if `object` does not .respond_to? `method`.
      #
      # @example
      #   assert_not_respond_to('bugbear', :nonexistence) # -> pass
      #   assert_not_respond_to('bugbear', :size)         # -> fail
      def assert_not_respond_to(object, method, message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       ".kind_of\\?(Symbol) or\n" +
                                       ".respond_to\\?(:to_str) expected",
                                       method, method)
          assert_block(full_message) do
            method.kind_of?(Symbol) or method.respond_to?(:to_str)
          end
          full_message = build_message(message,
                                       "!.respond_to\\?(?) expected\n" +
                                       "(Class: )",
                                       object, method, object.class)
          assert_block(full_message) {!object.respond_to?(method)}
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_respond_to, :assert_not_respond_to

      ##
      # Passes if `pattern` =~ `string`.
      #
      # @example
      #   assert_match(/\d+/, 'five, 6, seven')
      def assert_match(pattern, string, message=nil)
        _wrap_assertion do
          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
          full_message = build_message(message,
                                       " was expected to be =~\n.",
                                       pattern, string)
          assert_block(full_message) { pattern =~ string }
        end
      end

      ##
      # Passes if `actual` .equal? `expected` (i.e. they are the same
      # instance).
      #
      # @example
      #   o = Object.new
      #   assert_same o, o
      def assert_same(expected, actual, message=nil)
        full_message = build_message(message, <
with id  was expected to be equal\\? to

with id .
EOT
        assert_block(full_message) { actual.equal?(expected) }
      end

      ##
      # Compares the `object1` with `object2` using `operator`.
      #
      # Passes if object1.__send__(operator, object2) is not false nor nil.
      #
      # @example
      #   assert_operator 5, :>=, 4
      def assert_operator(object1, operator, object2, message=nil)
        _wrap_assertion do
          full_message = build_message(nil, "\ngiven as the operator for #assert_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
          assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
          full_message = build_message(message, < was expected to be
?
.
EOT
          assert_block(full_message) { object1.__send__(operator, object2) }
        end
      end

      ##
      # Compares the `object1` with `object2` using `operator`.
      #
      # Passes if object1.__send__(operator, object2) is false or nil.
      #
      # @example
      #   assert_not_operator(5, :<, 4) # => pass
      #   assert_not_operator(5, :>, 4) # => fail
      #
      # @since 3.0.0
      def assert_not_operator(object1, operator, object2, message=nil)
        _wrap_assertion do
          full_message = build_message(nil, "\ngiven as the operator for #assert_not_operator must be a Symbol or #respond_to\\?(:to_str).", operator)
          assert_block(full_message){operator.kind_of?(Symbol) || operator.respond_to?(:to_str)}
          full_message = build_message(message, < was expected to not be
?
.
EOT
          assert_block(full_message) { ! object1.__send__(operator, object2) }
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_operator, :assert_not_operator

      ##
      # Passes if block does not raise an exception.
      #
      # @example
      #   assert_nothing_raised do
      #     [1, 2].uniq
      #   end
      def assert_nothing_raised(*args)
        _wrap_assertion do
          if args.last.is_a?(String)
            message = args.pop
          else
            message = ""
          end

          assert_exception_helper = AssertExceptionHelper.new(self, args)
          begin
            yield
          rescue Exception => e
            if ((args.empty? && !e.instance_of?(AssertionFailedError)) ||
                assert_exception_helper.expected?(e))
              failure_message = build_message(message, "Exception raised:\n?", e)
              assert_block(failure_message) {false}
            else
              raise
            end
          end
        end
      end

      ##
      # Flunk always fails.
      #
      # @example
      #   flunk 'Not done testing yet.'
      def flunk(message="Flunked")
        assert_block(build_message(message)){false}
      end

      ##
      # Passes if ! `actual` .equal? `expected`
      #
      # @example
      #   assert_not_same Object.new, Object.new
      def assert_not_same(expected, actual, message=nil)
        full_message = build_message(message, <
with id  was expected to not be equal\\? to

with id .
EOT
        assert_block(full_message) { !actual.equal?(expected) }
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_same, :assert_not_same

      ##
      # Passes if `expected` != `actual`
      #
      # @example
      #   assert_not_equal 'some string', 5
      def assert_not_equal(expected, actual, message=nil)
        full_message = build_message(message,
                                     " was expected to be != to\n.",
                                     expected, actual)
        assert_block(full_message) { expected != actual }
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_equal, :assert_not_equal

      ##
      # Passes if ! `object` .nil?
      #
      # @example
      #   assert_not_nil '1 two 3'.sub!(/two/, '2')
      def assert_not_nil(object, message=nil)
        full_message = build_message(message,
                                     " was expected to not be nil.",
                                     object)
        assert_block(full_message){!object.nil?}
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_nil, :assert_not_nil

      ##
      # Passes if `regexp` !~ `string`
      #
      # @example
      #   assert_not_match(/two/, 'one 2 three')   # -> pass
      #   assert_not_match(/three/, 'one 2 three') # -> fail
      def assert_not_match(pattern, string, message=nil)
        _wrap_assertion do
          pattern = Regexp.new(Regexp.escape(pattern)) if pattern.is_a?(String)
          full_message = build_message(message,
                                       " was expected to not match\n.",
                                       pattern, string)
          assert_block(full_message) { pattern !~ string }
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_match, :assert_not_match

      ##
      # @deprecated Use {#assert_not_match} instead.
      #
      # Passes if `regexp` !~ `string`
      #
      # @example
      #   assert_no_match(/two/, 'one 2 three')   # -> pass
      #   assert_no_match(/three/, 'one 2 three') # -> fail
      def assert_no_match(regexp, string, message="")
        _wrap_assertion do
          assert_instance_of(Regexp, regexp,
                             "The first argument to assert_no_match " +
                             "should be a Regexp.")
          assert_not_match(regexp, string, message)
        end
      end

      # @private
      class ThrowTagExtractor
        @@have_uncaught_throw_error = const_defined?(:UncaughtThrowError)

        UncaughtThrowPatterns = {
          NameError => /^uncaught throw `(.+)'$/,
          ArgumentError => /^uncaught throw (`.+'|.+)$/,
          ThreadError => /^uncaught throw `(.+)' in thread /,
        }

        def initialize(error)
          @error = error
        end

        def extract_tag
          tag = nil
          if @@have_uncaught_throw_error
            return nil unless @error.is_a?(UncaughtThrowError)
            tag = @error.tag
          else
            pattern = UncaughtThrowPatterns[@error.class]
            return nil if pattern.nil?
            return nil unless pattern =~ @error.message
            tag = $1
          end
          normalize_tag(tag)
        end

        private
        def normalize_tag(tag)
          case tag
          when /\A:/
            tag[1..-1].intern
          when /\A`(.+)'\z/
            $1.intern
          when String
            tag.intern
          else
            tag
          end
        end
      end

      ##
      # Passes if the block throws `expected_object`
      #
      # @example
      #   assert_throw(:done) do
      #     throw(:done)
      #   end
      def assert_throw(expected_object, message=nil, &proc)
        _wrap_assertion do
          begin
            catch([]) {}
          rescue TypeError
            assert_instance_of(Symbol, expected_object,
                               "assert_throws expects the symbol that should be thrown for its first argument")
          end
          assert_block("Should have passed a block to assert_throw.") do
            block_given?
          end
          caught = true
          begin
            catch(expected_object) do
              proc.call
              caught = false
            end
            full_message = build_message(message,
                                         " should have been thrown.",
                                         expected_object)
            assert_block(full_message) {caught}
          rescue => error
            extractor = ThrowTagExtractor.new(error)
            tag = extractor.extract_tag
            raise if tag.nil?
            full_message = build_message(message,
                                         " was expected to be thrown but\n" +
                                         " was thrown.",
                                         expected_object, tag)
            flunk(full_message)
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :assert_throws, :assert_throw

      ##
      # Passes if block does not throw anything.
      #
      # @example
      #  assert_nothing_thrown do
      #    [1, 2].uniq
      #  end
      def assert_nothing_thrown(message=nil, &proc)
        _wrap_assertion do
          assert(block_given?, "Should have passed a block to assert_nothing_thrown")
          begin
            proc.call
          rescue => error
            extractor = ThrowTagExtractor.new(error)
            tag = extractor.extract_tag
            raise if tag.nil?
            full_message = build_message(message,
                                         " was thrown when nothing was expected",
                                         tag)
            flunk(full_message)
          end
          assert(true, "Expected nothing to be thrown")
        end
      end

      ##
      # Passes if `expected_float` and `actual_float` are equal
      # within `delta` tolerance.
      #
      # @example
      #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
      def assert_in_delta(expected_float, actual_float, delta=0.001, message="")
        _wrap_assertion do
          begin
            pass = delta >= (expected_float - actual_float).abs
            assert_operator(delta, :>=, 0.0, "The delta should not be negative")
            full_message = _assert_in_delta_message(expected_float,
                                                    expected_float,
                                                    actual_float,
                                                    actual_float,
                                                    delta,
                                                    delta,
                                                    message)
          rescue Test::Unit::AssertionFailedError
            # for the above assert_operator
            raise
          rescue
            _assert_in_delta_validate_arguments(expected_float,
                                                actual_float,
                                                delta)
            normalized_expected = expected_float.to_f
            normalized_actual = actual_float.to_f
            normalized_delta = delta.to_f
            pass = (normalized_expected - normalized_actual).abs <= normalized_delta
            full_message = _assert_in_delta_message(expected_float,
                                                    normalized_expected,
                                                    actual_float,
                                                    normalized_actual,
                                                    delta,
                                                    normalized_delta,
                                                    message)
          end
          assert_block(full_message) do
            pass
          end
        end
      end

      ##
      # Passes if `expected_float` and `actual_float` are
      # not equal within `delta` tolerance.
      #
      # @example
      #   assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00002) # -> pass
      #   assert_not_in_delta(0.05, (50000.0 / 10**6), 0.00001) # -> fail
      def assert_not_in_delta(expected_float, actual_float, delta=0.001, message="")
        _wrap_assertion do
          _assert_in_delta_validate_arguments(expected_float,
                                              actual_float,
                                              delta)
          begin
            pass = (expected_float - actual_float).abs > delta
            full_message = _assert_in_delta_message(expected_float,
                                                    expected_float,
                                                    actual_float,
                                                    actual_float,
                                                    delta,
                                                    delta,
                                                    message,
                                                    :negative_assertion => true)
          rescue
            normalized_expected = expected_float.to_f
            normalized_actual = actual_float.to_f
            normalized_delta = delta.to_f
            pass = (normalized_expected - normalized_actual).abs > normalized_delta
            full_message = _assert_in_delta_message(expected_float,
                                                    normalized_expected,
                                                    actual_float,
                                                    normalized_actual,
                                                    delta,
                                                    normalized_delta,
                                                    message,
                                                    :negative_assertion => true)
          end
          assert_block(full_message) do
            pass
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :refute_in_delta, :assert_not_in_delta

      private
      def _assert_in_delta_validate_arguments(expected_float,
                                              actual_float,
                                              delta)
        {
          expected_float => "first float",
          actual_float => "second float",
          delta => "delta"
        }.each do |float, name|
          assert_respond_to(float, :to_f,
                            "The arguments must respond to to_f; " +
                            "the #{name} did not")
        end
        delta = delta.to_f
        assert_operator(delta, :>=, 0.0, "The delta should not be negative")
      end

      def _assert_in_delta_message(expected_float, normalized_expected,
                                   actual_float, normalized_actual,
                                   delta, normalized_delta,
                                   message, options={})
        if options[:negative_assertion]
          format = <<-EOT
 -/+  was expected to not include
.
EOT
        else
          format = <<-EOT
 -/+  was expected to include
.
EOT
        end
        arguments = [expected_float, delta, actual_float]
        relation_format = nil
        relation_arguments = nil
        if normalized_actual < normalized_expected - normalized_delta
          relation_format = "< < -[?] <= +[?]>"
          relation_arguments = [actual_float,
                                expected_float, delta,
                                normalized_expected - normalized_delta,
                                expected_float, delta,
                                normalized_expected + normalized_delta]
        elsif normalized_actual <= normalized_expected + normalized_delta
          relation_format = "<-[?] <=  <= +[?]>"
          relation_arguments = [expected_float, delta,
                                normalized_expected - normalized_delta,
                                actual_float,
                                expected_float, delta,
                                normalized_expected + normalized_delta]
        else
          relation_format = "<-[?] <= +[?] < >"
          relation_arguments = [expected_float, delta,
                                normalized_expected - normalized_delta,
                                expected_float, delta,
                                normalized_expected + normalized_delta,
                                actual_float]
        end

        if relation_format
          format += <<-EOT

Relation:
#{relation_format}
EOT
          arguments.concat(relation_arguments)
        end

        build_message(message, format, *arguments)
      end

      public
      ##
      # Passes if `expected_float` and `actual_float` are equal
      # within `epsilon` relative error of `expected_float`.
      #
      # @example
      #   assert_in_epsilon(10000.0, 9900.0, 0.1) # -> pass
      #   assert_in_epsilon(10000.0, 9899.0, 0.1) # -> fail
      def assert_in_epsilon(expected_float, actual_float, epsilon=0.001,
                            message="")
        _wrap_assertion do
          begin
            zero_p = expected_float.zero? rescue expected_float == 0
            if zero_p
              delta = epsilon ** 2
            else
              delta = expected_float * epsilon
            end
            delta = delta.abs
            pass = (expected_float - actual_float).abs <= delta
            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
            full_message = _assert_in_epsilon_message(expected_float,
                                                      expected_float,
                                                      actual_float,
                                                      actual_float,
                                                      epsilon,
                                                      epsilon,
                                                      delta,
                                                      message)
          rescue Test::Unit::AssertionFailedError
            # for the above assert_operator
            raise
          rescue
            _assert_in_epsilon_validate_arguments(expected_float,
                                                  actual_float,
                                                  epsilon)
            normalized_expected = expected_float.to_f
            normalized_actual = actual_float.to_f
            normalized_epsilon = epsilon.to_f
            if normalized_expected.zero?
              delta = normalized_epsilon ** 2
            else
              delta = normalized_expected * normalized_epsilon
            end
            delta = delta.abs
            full_message = _assert_in_epsilon_message(expected_float,
                                                      normalized_expected,
                                                      actual_float,
                                                      normalized_actual,
                                                      epsilon,
                                                      normalized_epsilon,
                                                      delta,
                                                      message)
            pass = (normalized_expected - normalized_actual).abs <= delta
          end
          assert_block(full_message) do
            pass
          end
        end
      end

      ##
      # Passes if `expected_float` and `actual_float` are
      # not equal within `epsilon` relative error of
      # `expected_float`.
      #
      # @example
      #   assert_not_in_epsilon(10000.0, 9900.0, 0.1) # -> fail
      #   assert_not_in_epsilon(10000.0, 9899.0, 0.1) # -> pass
      def assert_not_in_epsilon(expected_float, actual_float, epsilon=0.001,
                                message="")
        _wrap_assertion do
          begin
            delta = expected_float * epsilon
            pass = (expected_float - actual_float).abs > delta
            assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
            full_message = _assert_in_epsilon_message(expected_float,
                                                      expected_float,
                                                      actual_float,
                                                      actual_float,
                                                      epsilon,
                                                      epsilon,
                                                      delta,
                                                      message,
                                                      :negative_assertion => true)
          rescue Test::Unit::AssertionFailedError
            # for the above assert_operator
            raise
          rescue
            _assert_in_epsilon_validate_arguments(expected_float,
                                                  actual_float,
                                                  epsilon)
            normalized_expected = expected_float.to_f
            normalized_actual = actual_float.to_f
            normalized_epsilon = epsilon.to_f
            delta = normalized_expected * normalized_epsilon
            pass = (normalized_expected - normalized_actual).abs > delta
            full_message = _assert_in_epsilon_message(expected_float,
                                                      normalized_expected,
                                                      actual_float,
                                                      normalized_actual,
                                                      epsilon,
                                                      normalized_epsilon,
                                                      delta,
                                                      message,
                                                      :negative_assertion => true)
          end
          assert_block(full_message) do
            pass
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_in_epsilon, :assert_not_in_epsilon

      private
      def _assert_in_epsilon_validate_arguments(expected_float,
                                                actual_float,
                                                epsilon)
        {
          expected_float => "first float",
          actual_float => "second float",
          epsilon => "epsilon"
        }.each do |float, name|
          assert_respond_to(float, :to_f,
                            "The arguments must respond to to_f; " +
                            "the #{name} did not")
        end
        epsilon = epsilon.to_f
        assert_operator(epsilon, :>=, 0.0, "The epsilon should not be negative")
      end

      def _assert_in_epsilon_message(expected_float, normalized_expected,
                                     actual_float, normalized_actual,
                                     epsilon, normalized_epsilon,
                                     delta, message, options={})
        if options[:negative_assertion]
          format = <<-EOT
 -/+ ( * )[?] was expected to not include
.
EOT
        else
          format = <<-EOT
 -/+ ( * )[?] was expected to include
.
EOT
        end
        arguments = [expected_float, expected_float, epsilon, delta,
                     actual_float]

        relation_format = nil
        relation_arguments = nil
        if normalized_actual < normalized_expected - delta
          relation_format = "< < -(*)[?] <= +(*)[?]>"
          relation_arguments = [actual_float,
                                expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta]
        elsif normalized_actual <= normalized_expected + delta
          relation_format = "<-(*)[?] <=  <= +(*)[?]>"
          relation_arguments = [expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                actual_float,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta]
        else
          relation_format = "<-(*)[?] <= +(*)[?] < >"
          relation_arguments = [expected_float, expected_float, epsilon,
                                normalized_expected - delta,
                                expected_float, expected_float, epsilon,
                                normalized_expected + delta,
                                actual_float]
        end

        if relation_format
          format += <<-EOT

Relation:
#{relation_format}
EOT
          arguments.concat(relation_arguments)
        end

        build_message(message, format, *arguments)
      end

      public
      ##
      # Passes if the method `__send__` returns not false nor nil.
      #
      # `send_array` is composed of:
      # * A receiver
      # * A method
      # * Arguments to the method
      #
      # @example
      #   assert_send([[1, 2], :member?, 1]) # -> pass
      #   assert_send([[1, 2], :member?, 4]) # -> fail
      def assert_send(send_array, message=nil)
        _wrap_assertion do
          assert_instance_of(Array, send_array,
                             "assert_send requires an array " +
                             "of send information")
          assert_operator(send_array.size, :>=, 2,
                          "assert_send requires at least a receiver " +
                          "and a message name")
          format = < was expected to respond to
 with a true value but was
.
EOT
          receiver, message_name, *arguments = send_array
          result = nil
          full_message =
            build_message(message,
                          format,
                          receiver,
                          AssertionMessage.literal(message_name.to_s),
                          arguments,
                          AssertionMessage.delayed_literal {result})
          assert_block(full_message) do
            result = receiver.__send__(message_name, *arguments)
            result
          end
        end
      end

      ##
      # Passes if the method `__send__` returns false or nil.
      #
      # `send_array` is composed of:
      # * A receiver
      # * A method
      # * Arguments to the method
      #
      # @example
      #   assert_not_send([[1, 2], :member?, 1]) # -> fail
      #   assert_not_send([[1, 2], :member?, 4]) # -> pass
      def assert_not_send(send_array, message=nil)
        _wrap_assertion do
          assert_instance_of(Array, send_array,
                             "assert_not_send requires an array " +
                             "of send information")
          assert_operator(send_array.size, :>=, 2,
                          "assert_not_send requires at least a receiver " +
                          "and a message name")
          format = < was expected to respond to
 with not a true value but was
.
EOT
          receiver, message_name, *arguments = send_array
          result = nil
          full_message =
            build_message(message,
                          format,
                          receiver,
                          AssertionMessage.literal(message_name.to_s),
                          arguments,
                          AssertionMessage.delayed_literal {result})
          assert_block(full_message) do
            result = receiver.__send__(message_name, *arguments)
            not result
          end
        end
      end

      ##
      # Passes if `actual` is a boolean value.
      #
      # @example
      #   assert_boolean(true) # -> pass
      #   assert_boolean(nil)  # -> fail
      def assert_boolean(actual, message=nil)
        _wrap_assertion do
          assert_block(build_message(message,
                                     " or  expected but was\n",
                                     actual)) do
            true == actual || false == actual
          end
        end
      end

      ##
      # Passes if `actual` is true.
      #
      # @example
      #   assert_true(true)  # -> pass
      #   assert_true(:true) # -> fail
      def assert_true(actual, message=nil)
        _wrap_assertion do
          assert_block(build_message(message,
                                     " expected but was\n",
                                     actual)) do
            true == actual
          end
        end
      end

      ##
      # Passes if `actual` is false.
      #
      # @example
      #   assert_false(false)  # -> pass
      #   assert_false(nil)    # -> fail
      def assert_false(actual, message=nil)
        _wrap_assertion do
          assert_block(build_message(message,
                                     " expected but was\n",
                                     actual)) do
            false == actual
          end
        end
      end

      ##
      # Passes if expression "`expected` `operator`
      # `actual`" is not false nor nil.
      #
      # @example
      #   assert_compare(1, "<", 10)  # -> pass
      #   assert_compare(1, ">=", 10) # -> fail
      def assert_compare(expected, operator, actual, message=nil)
        _wrap_assertion do
          assert_send([["<", "<=", ">", ">="], :include?, operator.to_s])
          case operator.to_s
          when "<"
            operator_description = "less than"
          when "<="
            operator_description = "less than or equal to"
          when ">"
            operator_description = "greater than"
          when ">="
            operator_description = "greater than or equal to"
          end
          template = <<-EOT
 #{operator}  should be true
 was expected to be #{operator_description}
.
EOT
          full_message = build_message(message, template,
                                       expected, actual,
                                       expected, actual)
          assert_block(full_message) do
            expected.__send__(operator, actual)
          end
        end
      end

      ##
      # Passes if assertion is failed in block.
      #
      # @example
      #   assert_fail_assertion {assert_equal("A", "B")}  # -> pass
      #   assert_fail_assertion {assert_equal("A", "A")}  # -> fail
      def assert_fail_assertion(message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       "Failed assertion was expected.")
          assert_block(full_message) do
            begin
              yield
              false
            rescue AssertionFailedError
              true
            end
          end
        end
      end

      ##
      # Passes if an exception is raised in block and its
      # message is `expected`.
      #
      # @example
      #   assert_raise_message("exception") {raise "exception"}  # -> pass
      #   assert_raise_message(/exc/i) {raise "exception"}       # -> pass
      #   assert_raise_message("exception") {raise "EXCEPTION"}  # -> fail
      #   assert_raise_message("exception") {}                   # -> fail
      def assert_raise_message(expected, message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       " exception message was expected " +
                                       "but none was thrown.",
                                       expected)
          exception = nil
          assert_block(full_message) do
            begin
              yield
              false
            rescue Exception => exception
              true
            end
          end

          actual = exception.message
          diff = AssertionMessage.delayed_diff(expected, actual)
          full_message =
            build_message(message,
                          " exception message expected but was\n" +
                          ".?", expected, actual, diff)
          assert_block(full_message) do
            if expected.is_a?(Regexp)
              expected =~ actual
            else
              expected == actual
            end
          end
        end
      end

      ##
      # Passes if `object`.const_defined?(`constant_name`)
      #
      # @example
      #   assert_const_defined(Test, :Unit)          # -> pass
      #   assert_const_defined(Object, :Nonexistent) # -> fail
      def assert_const_defined(object, constant_name, message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       ".const_defined\\?() expected.",
                                       object, constant_name)
          assert_block(full_message) do
            object.const_defined?(constant_name)
          end
        end
      end

      ##
      # Passes if !`object`.const_defined?(`constant_name`)
      #
      # @example
      #   assert_not_const_defined(Object, :Nonexistent) # -> pass
      #   assert_not_const_defined(Test, :Unit)          # -> fail
      def assert_not_const_defined(object, constant_name, message=nil)
        _wrap_assertion do
          full_message = build_message(message,
                                       "!.const_defined\\?() expected.",
                                       object, constant_name)
          assert_block(full_message) do
            !object.const_defined?(constant_name)
          end
        end
      end

      ##
      # Passes if `object`.`predicate` is not false nor nil.
      #
      # @example
      #   assert_predicate([], :empty?)  # -> pass
      #   assert_predicate([1], :empty?) # -> fail
      def assert_predicate(object, predicate, message=nil)
        _wrap_assertion do
          assert_respond_to(object, predicate, message)
          actual = object.__send__(predicate)
          full_message = build_message(message,
                                       ".? is true value expected but was\n" +
                                       "",
                                       object,
                                       AssertionMessage.literal(predicate),
                                       actual)
          assert_block(full_message) do
            actual
          end
        end
      end

      ##
      # Passes if `object`.`predicate` is false or nil.
      #
      # @example
      #   assert_not_predicate([1], :empty?) # -> pass
      #   assert_not_predicate([], :empty?)  # -> fail
      def assert_not_predicate(object, predicate, message=nil)
        _wrap_assertion do
          assert_respond_to(object, predicate, message)
          actual = object.__send__(predicate)
          full_message = build_message(message,
                                       ".? is false value expected but was\n" +
                                       "",
                                       object,
                                       AssertionMessage.literal(predicate),
                                       actual)
          assert_block(full_message) do
            not actual
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_predicate, :assert_not_predicate

      ##
      # Passes if `object`#`alias_name` is an alias method of
      # `object`#`original_name`.
      #
      # @example
      #   assert_alias_method([], :length, :size)  # -> pass
      #   assert_alias_method([], :size, :length)  # -> pass
      #   assert_alias_method([], :each, :size)    # -> fail
      def assert_alias_method(object, alias_name, original_name, message=nil)
        _wrap_assertion do
          find_method_failure_message = Proc.new do |method_name|
            build_message(message,
                          ".? doesn't exist\n" +
                          "(Class: )",
                          object,
                          AssertionMessage.literal(method_name),
                          object.class)
          end

          alias_method = original_method = nil
          assert_block(find_method_failure_message.call(alias_name)) do
            begin
              alias_method = object.method(alias_name)
              true
            rescue NameError
              false
            end
          end
          assert_block(find_method_failure_message.call(original_name)) do
            begin
              original_method = object.method(original_name)
              true
            rescue NameError
              false
            end
          end

          full_message = build_message(message,
                                       " is alias of\n" +
                                       " expected",
                                       alias_method,
                                       original_method)
          assert_block(full_message) do
            alias_method == original_method
          end
        end
      end

      ##
      # Passes if `path` exists.
      #
      # @example
      #   assert_path_exist("/tmp")          # -> pass
      #   assert_path_exist("/bin/sh")       # -> pass
      #   assert_path_exist("/nonexistent")  # -> fail
      def assert_path_exist(path, message=nil)
        _wrap_assertion do
          failure_message = build_message(message,
                                          " was expected to exist",
                                          path)
          assert_block(failure_message) do
            File.exist?(path)
          end
        end
      end

      ##
      # Passes if `path` doesn't exist.
      #
      # @example
      #   assert_path_not_exist("/nonexistent")  # -> pass
      #   assert_path_not_exist("/tmp")          # -> fail
      #   assert_path_not_exist("/bin/sh")       # -> fail
      def assert_path_not_exist(path, message=nil)
        _wrap_assertion do
          failure_message = build_message(message,
                                          " was expected to not exist",
                                          path)
          assert_block(failure_message) do
            not File.exist?(path)
          end
        end
      end

      ##
      # Passes if `collection` includes `object`.
      #
      # @example
      #   assert_include([1, 10], 1)            # -> pass
      #   assert_include(1..10, 5)              # -> pass
      #   assert_include([1, 10], 5)            # -> fail
      #   assert_include(1..10, 20)             # -> fail
      def assert_include(collection, object, message=nil)
        _wrap_assertion do
          assert_respond_to(collection, :include?,
                            "The collection must respond to :include?.")
          full_message = build_message(message,
                                       " was expected to include\n.",
                                       collection,
                                       object)
          assert_block(full_message) do
            collection.include?(object)
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 2.5.3
      alias_method :assert_includes, :assert_include

      ##
      # Passes if `collection` doesn't include `object`.
      #
      # @example
      #   assert_not_include([1, 10], 5)            # -> pass
      #   assert_not_include(1..10, 20)             # -> pass
      #   assert_not_include([1, 10], 1)            # -> fail
      #   assert_not_include(1..10, 5)              # -> fail
      def assert_not_include(collection, object, message=nil)
        _wrap_assertion do
          assert_respond_to(collection, :include?,
                            "The collection must respond to :include?.")
          full_message = build_message(message,
                                       " was expected to not include\n.",
                                       collection,
                                       object)
          assert_block(full_message) do
            not collection.include?(object)
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :assert_not_includes, :assert_not_include

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_includes, :assert_not_include

      ##
      # Passes if `object` is empty.
      #
      # @example
      #   assert_empty("")                       # -> pass
      #   assert_empty([])                       # -> pass
      #   assert_empty({})                       # -> pass
      #   assert_empty(" ")                      # -> fail
      #   assert_empty([nil])                    # -> fail
      #   assert_empty({1 => 2})                 # -> fail
      def assert_empty(object, message=nil)
        _wrap_assertion do
          assert_respond_to(object, :empty?,
                            "The object must respond to :empty?.")
          full_message = build_message(message,
                                       " was expected to be empty.",
                                       object)
          assert_block(full_message) do
            object.empty?
          end
        end
      end

      ##
      # Passes if `object` is not empty.
      #
      # @example
      #   assert_not_empty(" ")                      # -> pass
      #   assert_not_empty([nil])                    # -> pass
      #   assert_not_empty({1 => 2})                 # -> pass
      #   assert_not_empty("")                       # -> fail
      #   assert_not_empty([])                       # -> fail
      #   assert_not_empty({})                       # -> fail
      def assert_not_empty(object, message=nil)
        _wrap_assertion do
          assert_respond_to(object, :empty?,
                            "The object must respond to :empty?.")
          full_message = build_message(message,
                                       " was expected to not be empty.",
                                       object)
          assert_block(full_message) do
            not object.empty?
          end
        end
      end

      # Just for minitest compatibility. :<
      #
      # @since 3.0.0
      alias_method :refute_empty, :assert_not_empty

      # @overload assert_all(collection, message=nil, &block)
      #
      #   Asserts that all `block.call(item)` where `item` is each
      #   item in `collection` are not false nor nil.
      #
      #   If `collection` is empty, this assertion is always passed
      #   with any `block`.
      #
      #   @example Pass patterns
      #     assert_all([1, 2, 3]) {|item| item > 0} # => pass
      #     assert_all([1, 2, 3], &:positive?)      # => pass
      #     assert_all([]) {|item| false}           # => pass
      #
      #   @example Failure pattern
      #     assert_all([0, 1, 2], &:zero?) # => failure
      #
      #   @param [#each] collection The check target.
      #   @param [String] message The additional user message. It is
      #     showed when the assertion is failed.
      #   @yield [Object] Give each item in `collection` to the block.
      #   @yieldreturn [Object] The checked object.
      #   @return [void]
      #
      # @since 3.4.4
      def assert_all(collection, message=nil)
        _wrap_assertion do
          failed = false
          result = {}
          collection.each do |item|
            element_result = yield(item)
            failed = true unless element_result
            result[item] = element_result
          end
          format = <<-FORMAT
 was expected to be all true values with the given block but was

          FORMAT
          full_message = build_message(message,
                                       format,
                                       collection,
                                       result)
          assert_block(full_message) do
            not failed
          end
        end
      end

      # Just for Ruby's tool/lib/test/unit compatibility.
      #
      # @since 3.4.3
      alias_method :assert_all?, :assert_all

      # @overload assert_nothing_leaked_memory(max_increasable_size, target=:physical, message=nil, &block)
      #
      #   Asserts that increased memory usage by `block.call` is less
      #   than `max_increasable_size`. `GC.start` is called before and
      #   after `block.call`.
      #
      #   This assertion may be fragile. Because memory usage is
      #   depends on the current Ruby process's memory
      #   usage. Launching a new Ruby process for this will produce
      #   more stable result but we need to specify target code as
      #   `String` instead of block for the approach. We choose easy
      #   to write API approach rather than more stable result
      #   approach for this case.
      #
      #   @example Pass pattern
      #     require "objspace"
      #     size_per_object = ObjectSpace.memsize_of("Hello")
      #     # If memory isn't leaked, physical memory of almost created objects
      #     # (1000 - 10 objects) must be freed.
      #     assert_nothing_leaked_memory(size_per_object * 10) do
      #       1_000.times do
      #         "Hello".dup
      #       end
      #     end # => pass
      #
      #   @example Failure pattern
      #     require "objspace"
      #     size_per_object = ObjectSpace.memsize_of("Hello")
      #     strings = []
      #     assert_nothing_leaked_memory(size_per_object * 10) do
      #       10_000.times do
      #         # Created objects aren't GC-ed because they are referred.
      #         strings << "Hello".dup
      #       end
      #     end # => failure
      #
      #   @param target [:physical, :virtual] which memory usage is
      #     used for comparing. `:physical` means physical memory usage
      #     also known as Resident Set Size (RSS). `:virtual` means
      #     virtual memory usage.
      #   @yield [] do anything you want to measure memory usage
      #     in the block.
      #   @yieldreturn [void]
      #   @return [void]
      #
      # @since 3.4.5
      def assert_nothing_leaked_memory(max_increasable_size,
                                       target=:physical,
                                       message=nil)
        _wrap_assertion do
          GC.start
          before = Util::MemoryUsage.new
          unless before.collected?
            omit("memory usage collection isn't supported on this platform")
          end
          yield
          GC.start
          after = Util::MemoryUsage.new
          before_value = before.__send__(target)
          after_value = after.__send__(target)
          actual_increased_size = after_value - before_value
          template = <<-TEMPLATE
 was expected to be less than
.
          TEMPLATE
          full_message = build_message(message,
                                       template,
                                       actual_increased_size,
                                       max_increasable_size)
          assert_block(full_message) do
            actual_increased_size < max_increasable_size
          end
        end
      end

      ##
      # Builds a failure message.  `user_message` is added before the
      # `template` and `arguments` replaces the '?'s positionally in
      # the template.
      def build_message(user_message, template=nil, *arguments)
        template &&= template.chomp
        return AssertionMessage.new(user_message, template, arguments)
      end

      private
      def _wrap_assertion(&block)
        @_assertion_wrapped ||= false
        if @_assertion_wrapped
          block.call
        else
          @_assertion_wrapped = true
          begin
            add_assertion
            block.call
          ensure
            @_assertion_wrapped = false
          end
        end
      end

      public
      # Called whenever an assertion is made. Define this in classes
      # that include Test::Unit::Assertions to record assertion
      # counts.
      #
      # This is a public API for developers who extend test-unit.
      #
      # @return [void]
      def add_assertion
      end

      ##
      # Select whether or not to use the pretty-printer. If this option is set
      # to false before any assertions are made, pp.rb will not be required.
      def self.use_pp=(value)
        AssertionMessage.use_pp = value
      end

      private
      def _assert_raise(assert_expected_exception, *args, &block)
        _wrap_assertion do
          if args.last.is_a?(String)
            message = args.pop
          else
            message = ""
          end

          assert_exception_helper = AssertExceptionHelper.new(self, args)
          expected = assert_exception_helper.expected_exceptions
          actual_exception = nil
          full_message = build_message(message,
                                       " exception was expected " +
                                       "but none was thrown.",
                                       expected)
          assert_block(full_message) do
            begin
              yield
              false
            rescue Exception => actual_exception
              true
            end
          end
          assert_expected_exception.call(message, assert_exception_helper,
                                         actual_exception)
          actual_exception
        end
      end

      def _set_failed_information(failure, expected, actual)
        failure.expected = expected
        failure.actual = actual
        failure.inspected_expected = AssertionMessage.convert(expected)
        failure.inspected_actual = AssertionMessage.convert(actual)
      end

      class AssertionMessage
        @use_pp = true
        class << self
          attr_accessor :use_pp

          def literal(value)
            Literal.new(value)
          end

          def delayed_literal(&block)
            DelayedLiteral.new(block)
          end

          def maybe_container(value, &formatter)
            MaybeContainer.new(value, &formatter)
          end

          MAX_DIFF_TARGET_STRING_SIZE = 1000
          def max_diff_target_string_size
            return @@max_diff_target_string_size if @@max_diff_target_string_size

            size = ENV["TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"]
            if size
              begin
                size = Integer(size)
              rescue ArgumentError
                size = nil
              end
            end
            size || MAX_DIFF_TARGET_STRING_SIZE
          end

          @@max_diff_target_string_size = nil
          def max_diff_target_string_size=(size)
            @@max_diff_target_string_size = size
          end

          def diff_target_string?(string)
            if string.respond_to?(:bytesize)
              string.bytesize < max_diff_target_string_size
            else
              string.size < max_diff_target_string_size
            end
          end

          def ensure_diffable_string(string)
            if string.respond_to?(:encoding) and
                !string.encoding.ascii_compatible?
              string = string.dup.force_encoding("ASCII-8BIT")
            end
            string
          end

          def prepare_for_diff(from, to)
            if !from.is_a?(String) or !to.is_a?(String)
              from = convert(from)
              to = convert(to)
            end

            if diff_target_string?(from) and diff_target_string?(to)
              from = ensure_diffable_string(from)
              to = ensure_diffable_string(to)
              [from, to]
            else
              [nil, nil]
            end
          end

          def delayed_diff(from, to)
            delayed_literal do
              from, to = prepare_for_diff(from, to)

              diff = "" if from.nil? or to.nil?
              diff ||= Diff.readable(from, to)
              if /^[-+]/ !~ diff
                diff = ""
              elsif /^[ ?]/ =~ diff or /(?:.*\n){2,}/ =~ diff
                diff = "\n\ndiff:\n#{diff}"
              else
                diff = ""
              end

              if Diff.need_fold?(diff)
                folded_diff = Diff.folded_readable(from, to)
                diff += "\n\nfolded diff:\n#{folded_diff}"
              end

              diff
            end
          end

          def convert(object)
            if object.is_a?(Exception)
              object = AssertExceptionHelper::WrappedException.new(object)
            end
            inspector = Inspector.new(object)
            if use_pp
              begin
                require "pp" unless defined?(PP)
                begin
                  return PP.pp(inspector, String.new).chomp
                rescue NameError
                end
              rescue LoadError
                self.use_pp = false
              end
            end
            inspector.inspect
          end
        end

        class Inspector
          include Comparable

          class << self
            def cached_new(object, inspected_objects)
              inspected_objects[object.object_id] ||=
                new(object, inspected_objects)
            end

            @@inspector_classes = []
            def inspector_classes
              @@inspector_classes
            end

            def register_inspector_class(inspector_class)
              @@inspector_classes << inspector_class
            end

            def unregister_inspector_class(inspector_class)
              @@inspector_classes.delete(inspector_class)
            end
          end

          attr_reader :object
          def initialize(object, inspected_objects={})
            @inspected_objects = inspected_objects
            @object = object
            @inspected_objects[@object.object_id] = self
            @inspect_target = inspect_target
          end

          alias_method :native_inspect, :inspect
          def inspect
            @inspect_target.inspect
          end

          def pretty_print(q)
            @inspect_target.pretty_print(q)
          end

          def pretty_print_cycle(q)
            @inspect_target.pretty_print_cycle(q)
          end

          def <=>(other)
            if other.is_a?(self.class)
              @object <=> other.object
            else
              @object <=> other
            end
          end

          private
          def inspect_target
            self.class.inspector_classes.each do |inspector_class|
              if inspector_class.target?(@object)
                return inspector_class.new(@object, @inspected_objects)
              end
            end
            @object
          end
        end

        class NumericInspector
          Inspector.register_inspector_class(self)

          class << self
            def target?(object)
              object.is_a?(Numeric)
            end
          end

          def initialize(numeric, inspected_objects)
            @inspected_objects = inspected_objects
            @numeric = numeric
          end

          def inspect
            @numeric.to_s
          end

          def pretty_print(q)
            q.text(@numeric.to_s)
          end

          def pretty_print_cycle(q)
            q.text(@numeric.to_s)
          end
        end

        class HashInspector
          Inspector.register_inspector_class(self)

          class << self
            def target?(object)
              object.is_a?(Hash) or ENV.equal?(object)
            end
          end

          def initialize(hash, inspected_objects)
            @inspected_objects = inspected_objects
            @hash = {}
            hash.each do |key, value|
              key = Inspector.cached_new(key, @inspected_objects)
              value = Inspector.cached_new(value, @inspected_objects)
              @hash[key] = value
            end
          end

          def inspect
            @hash.inspect
          end

          def pretty_print(q)
            q.group(1, '{', '}') do
              q.seplist(self, nil, :each_pair) do |k, v|
                q.group do
                  q.pp(k)
                  q.text('=>')
                  q.group(1) do
                    q.breakable('')
                    q.pp(v)
                  end
                end
              end
            end
          end

          def pretty_print_cycle(q)
            @hash.pretty_print_cycle(q)
          end

          def each_pair
            keys = @hash.keys
            begin
              keys = keys.sort # FIXME: more cleverly
            rescue ArgumentError
            end
            keys.each do |key|
              yield(key, @hash[key])
            end
          end
        end

        class ArrayInspector
          Inspector.register_inspector_class(self)

          class << self
            def target?(object)
              object.is_a?(Array)
            end
          end

          def initialize(array, inspected_objects)
            @inspected_objects = inspected_objects
            @array = array.collect do |element|
              Inspector.cached_new(element, @inspected_objects)
            end
          end

          def inspect
            @array.inspect
          end

          def pretty_print(q)
            q.group(1, '[', ']') do
              q.seplist(self) do |v|
                q.pp(v)
              end
            end
          end

          def pretty_print_cycle(q)
            @array.pretty_print_cycle(q)
          end

          def each(&block)
            @array.each(&block)
          end
        end

        class Literal
          def initialize(value)
            @value = value
          end

          def inspect
            @value.to_s
          end
        end

        class DelayedLiteral
          def initialize(value)
            @value = value
          end

          def inspect
            @value.call.to_s
          end
        end

        class MaybeContainer
          def initialize(value, &formatter)
            @value = value
            @formatter = formatter
          end

          def inspect
            if @value.is_a?(Array)
              values = @value.collect do |value|
                @formatter.call(AssertionMessage.convert(value))
              end
              "[#{values.join(', ')}]"
            else
              @formatter.call(AssertionMessage.convert(@value))
            end
          end
        end

        class Template
          def self.create(string)
            parts = (string ? string.scan(/(?=[^\\])\?|(?:\\\?|[^\?])+/m) : [])
            self.new(parts)
          end

          attr_reader :count

          def initialize(parts)
            @parts = parts
            @count = parts.find_all{|e| e == '?'}.size
          end

          def result(parameters)
            raise "The number of parameters does not match the number of substitutions." if(parameters.size != count)
            params = parameters.dup
            expanded_template = ""
            @parts.each do |part|
              if part == '?'
                param = params.shift
                if Object.const_defined?(:Encoding)
                  expanded_template += concatenatable(param,
                                                      expanded_template.encoding)
                else
                  expanded_template += param
                end
              else
                expanded_template += part.gsub(/\\\?/m, '?')
              end
            end
            expanded_template
          end

          private
          def concatenatable(text, encoding)
            if Encoding.compatible?(text, encoding)
              text
            else
              text.dup.force_encoding(encoding)
            end
          end
        end

        include Util::BacktraceFilter

        def initialize(user_message, template_string, parameters)
          @user_message = user_message
          @template_string = template_string
          @parameters = parameters
        end

        def convert(object)
          self.class.convert(object)
        end

        def template
          @template ||= Template.create(@template_string)
        end

        def user_message
          return nil unless @user_message
          message = @user_message
          message = message.call if message.respond_to?(:call)
          message.to_s
        end

        def to_s
          message_parts = []
          head = user_message
          if head and not head.empty?
            message_parts << add_period(head)
          end
          tail = template.result(@parameters.collect{|e| convert(e)})
          message_parts << tail unless(tail.empty?)
          message_parts.join("\n")
        end

        private
        def add_period(string)
          (string =~ /\.\Z/ ? string : string + '.')
        end
      end

      class AssertExceptionHelper
        class WrappedException
          attr_reader :exception
          def initialize(exception)
            @exception = exception
          end

          def inspect
            if default_inspect?
              inspected = "#{@exception.class.inspect}(<#{@exception.message}>)"
              unless (@exception.backtrace || []).empty?
                inspected += "\n"
                @exception.backtrace.each do |trace|
                  inspected << "#{trace}\n"
                end
              end
              inspected
            else
              @exception.inspect
            end
          end

          def method_missing(name, *args, &block)
            @exception.__send__(name, *args, &block)
          end

          private
          def default_inspect?
            inspect_method = @exception.method(:inspect)
            if inspect_method.respond_to?(:owner) and
                inspect_method.owner == Exception
              true
            else
              default_inspect_method = Exception.instance_method(:inspect)
              default_inspect_method.bind(@exception).call == @exception.inspect
            end
          end
        end

        def initialize(test_case, expected_exceptions)
          @test_case = test_case
          @expected_exceptions = expected_exceptions
          @expected_classes, @expected_modules, @expected_objects =
            split_expected_exceptions(expected_exceptions)
        end

        def expected_exceptions
          exceptions = @expected_exceptions.collect do |exception|
            if exception.is_a?(Exception)
              WrappedException.new(exception)
            else
              exception
            end
          end
          if exceptions.size == 1
            exceptions[0]
          else
            exceptions
          end
        end

        def expected?(actual_exception, equality=nil)
          equality ||= :instance_of?
          expected_class?(actual_exception, equality) or
            expected_module?(actual_exception) or
            expected_object?(actual_exception)
        end

        private
        def split_expected_exceptions(expected_exceptions)
          exception_modules = []
          exception_objects = []
          exception_classes = []
          expected_exceptions.each do |exception_type|
            if exception_type.instance_of?(Module)
              exception_modules << exception_type
            elsif exception_object?(exception_type)
              exception_objects << exception_type
            elsif exception_class?(exception_type)
              exception_classes << exception_type
            else
              full_message =
                @test_case.__send__(:build_message,
                                    nil,
                                    " must be " +
                                    "a subclass of Exception, " +
                                    "an object of Exception subclasses " +
                                    "or a Module",
                                    exception_type)
              @test_case.flunk(full_message)
            end
          end
          [exception_classes, exception_modules, exception_objects]
        end

        def exception_object?(exception_type)
          return true if exception_type.is_a?(Exception)

          if Object.const_defined?(:Java)
            return true if exception_type.is_a?(Java::JavaLang::Throwable)
          end

          false
        end

        def exception_class?(exception_type)
          return true if exception_type <= Exception

          if Object.const_defined?(:Java)
            return true if exception_type <= Java::JavaLang::Throwable
          end

          false
        end

        def expected_class?(actual_exception, equality)
          @expected_classes.any? do |expected_class|
            actual_exception.__send__(equality, expected_class)
          end
        end

        def expected_module?(actual_exception)
          @expected_modules.any? do |expected_module|
            actual_exception.is_a?(expected_module)
          end
        end

        def expected_object?(actual_exception)
          @expected_objects.any? do |expected_object|
            expected_object == actual_exception or
              fallback_exception_object_equal(expected_object, actual_exception)
          end
        end

        def fallback_exception_object_equal(expected_object, actual_exception)
          owner = Util::MethodOwnerFinder.find(expected_object, :==)
          if owner == Kernel or owner == Exception
            expected_object.class == actual_exception.class and
              expected_object.message == actual_exception.message
          else
            false
          end
        end
      end

      # :startdoc:
    end
  end
end
test-unit-3.6.2/lib/test/unit/attribute-matcher.rb000066400000000000000000000006571456346657200221650ustar00rootroot00000000000000module Test
  module Unit
    class AttributeMatcher
      def initialize(test)
        @test = test
      end

      def match?(expression)
        matched = instance_eval(expression)
        if matched.nil?
          false
        else
          matched
        end
      end

      def method_missing(name, *args)
        if args.empty?
          @test[name]
        else
          super
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/attribute.rb000066400000000000000000000161251456346657200205410ustar00rootroot00000000000000module Test
  module Unit
    module Attribute
      class StringifyKeyHash < Hash
        class << self
          def stringify(object)
            object.to_s
          end
        end

        def key?(key)
          super(self.class.stringify(key))
        end

        def [](key)
          super(self.class.stringify(key))
        end

        def []=(key, value)
          super(self.class.stringify(key), value)
        end
      end

      class << self
        def included(base)
          base.extend(BaseClassMethods)
          base.extend(ClassMethods)
        end
      end

      module BaseClassMethods
        def attributes_table
          {}
        end
      end

      module ClassMethods
        def method_added(name)
          super
          return unless defined?(@current_attributes)

          attributes = {}
          kept_attributes = StringifyKeyHash.new
          @current_attributes.each do |attribute_name, attribute|
            attributes[attribute_name] = attribute[:value]
            if attribute[:keep]
              keep_hook = attribute[:keep_hook]
              attribute = keep_hook.call(attribute) if keep_hook
              kept_attributes[attribute_name] = attribute
            end
          end
          set_attributes(name, attributes)
          @current_attributes = kept_attributes
        end

        # Set an attribute to test methods.
        #
        # @overload attribute(name, value)
        #   @example
        #     attribute :speed, :slow
        #     def test_my_slow_method
        #       self[:speed] # => :slow
        #     end
        #
        #   @param [Object] name the attribute name
        #   @param [Object] value the attribute value
        #   @return [void]
        #
        # @overload attribute(name, value, *method_names)
        #   @example
        #     def test_my_slow_method1
        #       self[:speed] # => :slow
        #     end
        #
        #     attribute :speed, :slow, :test_my_slow_method1, :test_my_slow_method2
        #
        #     def test_my_slow_method2
        #       self[:speed] # => :slow
        #     end
        #
        #   @param [Object] name the attribute name
        #   @param [Object] value the attribute value
        #   @param [Array] method_names the test method names set the attribute
        #   @return [void]
        #
        # @overload attribute(name, value, options)
        #   @example
        #     attribute :speed, :slow, keep: true
        #     def test_my_slow_method1
        #       self[:speed] # => :slow
        #     end
        #
        #     def test_my_slow_method2
        #       self[:speed] # => :slow
        #     end
        #
        #   @param [Object] name the attribute name
        #   @param [Object] value the attribute value
        #   @option options [Boolean] :keep whether or not to set attribute to following test methods
        #   @return [void]
        #
        # @overload attribute(name, value, options, *method_names)
        #   @example
        #     def test_my_slow_method1
        #       self[:speed] # => :slow
        #     end
        #
        #     # There are no valid options for now.
        #     attribute :speed, :slow, {}, :test_my_slow_method1
        #
        #     def test_my_slow_method2
        #       self[:speed] # => nil
        #     end
        #
        #   @param [Object] name the attribute name
        #   @param [Object] value the attribute value
        #   @param [Hash] options ignored
        #   @param [Array] method_names the test method names set the attribute
        #   @return [void]
        def attribute(name, value, options={}, *method_names)
          unless options.is_a?(Hash)
            method_names << options
            options = {}
          end
          if method_names.empty?
            current_attributes[name] = options.merge(:value => value)
          else
            method_names.each do |method_name|
              set_attributes(method_name, {name => value})
            end
          end
        end

        def current_attributes
          @current_attributes ||= StringifyKeyHash.new
        end

        def current_attribute(name)
          current_attributes[name] || StringifyKeyHash.new
        end

        def attributes_table
          @attributes_table ||= StringifyKeyHash.new
          super.merge(@attributes_table)
        end

        def set_attributes(method_name, new_attributes)
          return if new_attributes.empty?
          @attributes_table ||= StringifyKeyHash.new
          @attributes_table[method_name] ||= StringifyKeyHash.new
          current_attributes = @attributes_table[method_name]
          new_attributes.each do |key, value|
            observers = attribute_observers(key) || []
            observers.each do |observer|
              observer.call(self,
                            StringifyKeyHash.stringify(key),
                            (attributes(method_name) || {})[key],
                            value,
                            method_name)
            end
            current_attributes[key] = value
          end
        end

        def attributes(method_name)
          attributes = attributes_table[method_name]
          ancestors.each do |ancestor|
            next if ancestor == self
            if ancestor.is_a?(Class) and ancestor < Test::Unit::Attribute
              parent_attributes = ancestor.attributes(method_name)
              if attributes
                attributes = (parent_attributes || {}).merge(attributes)
              else
                attributes = parent_attributes
              end
              break
            end
          end
          attributes || StringifyKeyHash.new
        end

        def find_attribute(method_name, name, options={})
          recursive_p = options[:recursive]
          recursive_p = true if recursive_p.nil?

          @attributes_table ||= StringifyKeyHash.new
          if @attributes_table.key?(method_name)
            attributes = @attributes_table[method_name]
            if attributes.key?(name)
              return attributes[name]
            end
          end

          return nil unless recursive_p
          return nil if self == TestCase

          @cached_parent_test_case ||= ancestors.find do |ancestor|
            ancestor != self and
              ancestor.is_a?(Class) and
              ancestor < Test::Unit::Attribute
          end
          return nil if @cached_parent_test_case.nil?

          @cached_parent_test_case.find_attribute(method_name, name, options)
        end

        @@attribute_observers = StringifyKeyHash.new
        def register_attribute_observer(attribute_name, observer=nil, &block)
          observer ||= Proc.new(&block)
          @@attribute_observers[attribute_name] ||= []
          @@attribute_observers[attribute_name] << observer
        end

        def attribute_observers(attribute_name)
          @@attribute_observers[attribute_name]
        end
      end

      def attributes
        self.class.attributes(@method_name) || StringifyKeyHash.new
      end

      def [](name)
        self.class.find_attribute(@method_name, name)
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/auto-runner-loader.rb000066400000000000000000000005731456346657200222610ustar00rootroot00000000000000require "test/unit/test-suite-creator"

module Test
  module Unit
    module AutoRunnerLoader
      @loaded = false
      class << self
        def check(test_case, method_name)
          return if @loaded
          return unless TestSuiteCreator.test_method?(test_case, method_name)
          require "test/unit"
          @loaded = true
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/autorunner.rb000066400000000000000000000451241456346657200207410ustar00rootroot00000000000000require "English"
require "optparse"

require "test/unit/color-scheme"
require "test/unit/priority"
require "test/unit/attribute-matcher"
require "test/unit/testcase"

module Test
  module Unit
    class AutoRunner
      RUNNERS = {}
      COLLECTORS = {}
      ADDITIONAL_OPTIONS = []
      PREPARE_HOOKS = []

      class << self
        def register_runner(id, runner_builder=nil, &block)
          runner_builder ||= Proc.new(&block)
          RUNNERS[id] = runner_builder
          RUNNERS[id.to_s] = runner_builder
        end

        def runner(id)
          RUNNERS[id.to_s]
        end

        @@default_runner = nil
        def default_runner
          runner(@@default_runner)
        end

        def default_runner=(id)
          @@default_runner = id
        end

        def register_collector(id, collector_builder=nil, &block)
          collector_builder ||= Proc.new(&block)
          COLLECTORS[id] = collector_builder
          COLLECTORS[id.to_s] = collector_builder
        end

        def collector(id)
          COLLECTORS[id.to_s]
        end

        def register_color_scheme(id, scheme)
          ColorScheme[id] = scheme
        end

        def setup_option(option_builder=nil, &block)
          option_builder ||= Proc.new(&block)
          ADDITIONAL_OPTIONS << option_builder
        end

        def prepare(hook=nil, &block)
          hook ||= Proc.new(&block)
          PREPARE_HOOKS << hook
        end

        def run(force_standalone=false, default_dir=nil, argv=ARGV, &block)
          r = new(force_standalone || standalone?, &block)
          r.base = default_dir
          r.prepare
          r.process_args(argv)
          r.run
        end

        def standalone?
          return false unless("-e" == $0)
          ObjectSpace.each_object(Class) do |klass|
            return false if(klass < TestCase)
          end
          true
        end

        @@need_auto_run = true
        def need_auto_run?
          @@need_auto_run
        end

        def need_auto_run=(need)
          @@need_auto_run = need
        end
      end

      register_collector(:descendant) do |auto_runner|
        require "test/unit/collector/descendant"
        collector = Collector::Descendant.new
        collector.filter = auto_runner.filters
        collector.collect($0.sub(/\.rb\Z/, ""))
      end

      register_collector(:load) do |auto_runner|
        require "test/unit/collector/load"
        collector = Collector::Load.new
        unless auto_runner.pattern.empty?
          collector.patterns.replace(auto_runner.pattern)
        end
        unless auto_runner.exclude.empty?
          collector.excludes.replace(auto_runner.exclude)
        end
        collector.base = auto_runner.base
        collector.default_test_paths = auto_runner.default_test_paths
        collector.filter = auto_runner.filters
        collector.collect(*auto_runner.to_run)
      end

      # JUST TEST!
      # register_collector(:xml) do |auto_runner|
      #   require "test/unit/collector/xml"
      #   collector = Collector::XML.new
      #   collector.filter = auto_runner.filters
      #   collector.collect(auto_runner.to_run[0])
      # end

      # deprecated
      register_collector(:object_space) do |auto_runner|
        require "test/unit/collector/objectspace"
        c = Collector::ObjectSpace.new
        c.filter = auto_runner.filters
        c.collect($0.sub(/\.rb\Z/, ""))
      end

      # deprecated
      register_collector(:dir) do |auto_runner|
        require "test/unit/collector/dir"
        c = Collector::Dir.new
        c.filter = auto_runner.filters
        unless auto_runner.pattern.empty?
          c.pattern.replace(auto_runner.pattern)
        end
        unless auto_runner.exclude.empty?
          c.exclude.replace(auto_runner.exclude)
        end
        c.base = auto_runner.base
        $:.push(auto_runner.base) if auto_runner.base
        c.collect(*(auto_runner.to_run.empty? ? ["."] : auto_runner.to_run))
      end

      attr_reader :suite, :runner_options
      attr_accessor :filters, :to_run
      attr_accessor :default_test_paths
      attr_accessor :pattern, :exclude, :base, :workdir
      attr_accessor :color_scheme, :listeners
      attr_writer :stop_on_failure
      attr_writer :debug_on_failure
      attr_writer :gc_stress
      attr_writer :runner, :collector

      def initialize(standalone)
        @standalone = standalone
        @runner = default_runner
        @collector = default_collector
        @filters = []
        @to_run = []
        @default_test_paths = []
        @color_scheme = ColorScheme.default
        @runner_options = {}
        @default_arguments = []
        @workdir = nil
        @listeners = []
        @stop_on_failure = false
        @debug_on_failure = false
        @gc_stress = false
        config_file = "test-unit.yml"
        if File.exist?(config_file)
          load_config(config_file)
        else
          load_global_config
        end
        yield(self) if block_given?
      end

      def stop_on_failure?
        @stop_on_failure
      end

      def debug_on_failure?
        @debug_on_failure
      end

      def prepare
        PREPARE_HOOKS.each do |handler|
          handler.call(self)
        end
      end

      def process_args(args=ARGV)
        begin
          args.unshift(*@default_arguments)
          options.order!(args) {|arg| add_test_path(arg)}
        rescue OptionParser::ParseError => e
          puts e
          puts options
          exit(false)
        end
        not @to_run.empty?
      end

      def options
        @options ||= OptionParser.new do |o|
          o.banner = "Test::Unit automatic runner."
          o.banner += "\nUsage: #{$0} [options] [-- untouched arguments]"

          o.on("-r", "--runner=RUNNER", RUNNERS,
               "Use the given RUNNER.",
               "(" + keyword_display(RUNNERS) + ")") do |r|
            @runner = r
          end

          o.on("--collector=COLLECTOR", COLLECTORS,
               "Use the given COLLECTOR.",
               "(" + keyword_display(COLLECTORS) + ")") do |collector|
            @collector = collector
          end

          if (@standalone)
            o.on("-b", "--basedir=DIR", "Base directory of test suites.") do |b|
              @base = b
            end

            o.on("-w", "--workdir=DIR", "Working directory to run tests.") do |w|
              @workdir = w
            end

            o.on("--default-test-path=PATH",
                 "Add PATH to the default test paths.",
                 "The PATH is used when user doesn't specify any test path.",
                 "You can specify this option multiple times.") do |path|
              @default_test_paths << path
            end

            o.on("-a", "--add=TORUN", Array,
                 "Add TORUN to the list of things to run;",
                 "can be a file or a directory.") do |paths|
              paths.each do |path|
                add_test_path(path)
              end
            end

            @pattern = []
            o.on("-p", "--pattern=PATTERN", Regexp,
                 "Match files to collect against PATTERN.") do |e|
              @pattern << e
            end

            @exclude = []
            o.on("-x", "--exclude=PATTERN", Regexp,
                 "Ignore files to collect against PATTERN.") do |e|
              @exclude << e
            end
          end

          o.on("-n", "--name=NAME", String,
               "Runs tests matching NAME.",
               "Use '/PATTERN/' for NAME to use regular expression.",
               "Regular expression accepts options.",
               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
            name = prepare_name(name)
            @filters << lambda do |test|
              match_test_name(test, name)
            end
          end

          o.on("--ignore-name=NAME", String,
               "Ignores tests matching NAME.",
               "Use '/PATTERN/' for NAME to use regular expression.",
               "Regular expression accepts options.",
               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
            name = prepare_name(name)
            @filters << lambda do |test|
              not match_test_name(test, name)
            end
          end

          o.on("-t", "--testcase=TESTCASE", String,
               "Runs tests in TestCases matching TESTCASE.",
               "Use '/PATTERN/' for TESTCASE to use regular expression.",
               "Regular expression accepts options.",
               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
            name = prepare_name(name)
            @filters << lambda do |test|
              match_test_case_name(test, name)
            end
          end

          o.on("--ignore-testcase=TESTCASE", String,
               "Ignores tests in TestCases matching TESTCASE.",
               "Use '/PATTERN/' for TESTCASE to use regular expression.",
               "Regular expression accepts options.",
               "Example: '/taRget/i' matches 'target' and 'TARGET'") do |name|
            name = prepare_name(name)
            @filters << lambda do |test|
              not match_test_case_name(test, name)
            end
          end

          o.on("--location=LOCATION", String,
               "Runs tests that defined in LOCATION.",
               "LOCATION is one of PATH:LINE, PATH or LINE.") do |location|
            case location
            when /\A(\d+)\z/
              path = nil
              line = $1.to_i
            when /:(\d+)\z/
              path = $PREMATCH
              line = $1.to_i
            else
              path = location
              line = nil
            end
            add_location_filter(path, line)
          end

          o.on("--attribute=EXPRESSION", String,
               "Runs tests that matches EXPRESSION.",
               "EXPRESSION is evaluated as Ruby's expression.",
               "Test attribute name can be used with no receiver in EXPRESSION.",
               "EXPRESSION examples:",
               "  !slow",
               "  tag == 'important' and !slow") do |expression|
            @filters << lambda do |test|
              matcher = AttributeMatcher.new(test)
              matcher.match?(expression)
            end
          end

          priority_filter = Proc.new do |test|
            if @filters == [priority_filter]
              Priority::Checker.new(test).need_to_run?
            else
              nil
            end
          end
          o.on("--[no-]priority-mode",
               "Runs some tests based on their priority.") do |priority_mode|
            if priority_mode
              Priority.enable
              @filters |= [priority_filter]
            else
              Priority.disable
              @filters -= [priority_filter]
            end
          end

          o.on("--default-priority=PRIORITY",
               Priority.available_values,
               "Uses PRIORITY as default priority",
               "(#{keyword_display(Priority.available_values)})") do |priority|
            Priority.default = priority
          end

          o.on("-I", "--load-path=DIR[#{File::PATH_SEPARATOR}DIR...]",
               "Appends directory list to $LOAD_PATH.") do |dirs|
            $LOAD_PATH.concat(dirs.split(File::PATH_SEPARATOR))
          end

          color_schemes = ColorScheme.all
          o.on("--color-scheme=SCHEME", color_schemes,
               "Use SCHEME as color scheme.",
               "(#{keyword_display(color_schemes)})") do |scheme|
            @color_scheme = scheme
          end

          o.on("--config=FILE",
               "Use YAML format FILE content as configuration file.") do |file|
            load_config(file)
          end

          o.on("--order=ORDER", TestCase::AVAILABLE_ORDERS,
               "Run tests in a test case in ORDER order.",
               "(#{keyword_display(TestCase::AVAILABLE_ORDERS)})") do |order|
            TestCase.test_order = order
          end

          assertion_message_class = Test::Unit::Assertions::AssertionMessage
          o.on("--max-diff-target-string-size=SIZE", Integer,
               "Shows diff if both expected result string size and " +
               "actual result string size are " +
               "less than or equal SIZE in bytes.",
               "(#{assertion_message_class.max_diff_target_string_size})") do |size|
            assertion_message_class.max_diff_target_string_size = size
          end

          o.on("--[no-]stop-on-failure",
               "Stops immediately on the first non success test",
               "(#{@stop_on_failure})") do |boolean|
            @stop_on_failure = boolean
          end

          o.on("--[no-]debug-on-failure",
               "Run debugger if available on failure",
               "(#{AssertionFailedError.debug_on_failure?})") do |boolean|
            AssertionFailedError.debug_on_failure = boolean
          end

          o.on("--[no-]gc-stress",
               "Enable GC.stress only while each test is running",
               "(#{@gc_stress})") do |boolean|
            @gc_stress = boolean
          end

          ADDITIONAL_OPTIONS.each do |option_builder|
            option_builder.call(self, o)
          end

          o.on("--",
               "Stop processing options so that the",
               "remaining options will be passed to the",
               "test."){o.terminate}

          o.on("-h", "--help", "Display this help."){puts o; exit}

          o.on_tail
          o.on_tail("Deprecated options:")

          o.on_tail("--console", "Console runner (use --runner).") do
            warn("Deprecated option (--console).")
            @runner = self.class.runner(:console)
          end

          if RUNNERS[:fox]
            o.on_tail("--fox", "Fox runner (use --runner).") do
              warn("Deprecated option (--fox).")
              @runner = self.class.runner(:fox)
            end
          end

          o.on_tail
        end
      end

      def keyword_display(keywords)
        keywords = keywords.collect do |keyword, _|
          keyword.to_s
        end.uniq.sort

        i = 0
        keywords.collect do |keyword|
          if (i > 0 and keyword[0] == keywords[i - 1][0]) or
              ((i < keywords.size - 1) and (keyword[0] == keywords[i + 1][0]))
            n = 2
          else
            n = 1
          end
          i += 1
          keyword.sub(/^(.{#{n}})([A-Za-z-]+)(?=\w*$)/, '\\1[\\2]')
        end.join(", ")
      end

      def run
        self.class.need_auto_run = false
        suite = @collector[self]
        return false if suite.nil?
        return true if suite.empty?
        runner = @runner[self]
        return false if runner.nil?
        @runner_options[:color_scheme] ||= @color_scheme
        @runner_options[:listeners] ||= []
        @runner_options[:listeners].concat(@listeners)
        if @stop_on_failure
          @runner_options[:listeners] << StopOnFailureListener.new
        end
        if @gc_stress
          @runner_options[:listeners] << GCStressListener.new
        end
        change_work_directory do
          runner.run(suite, @runner_options).passed?
        end
      end

      def load_config(file)
        require "yaml"
        config = YAML.load(File.read(file))
        runner_name = config["runner"]
        @runner = self.class.runner(runner_name) || @runner
        @collector = self.class.collector(config["collector"]) || @collector
        (config["color_schemes"] || {}).each do |name, options|
          ColorScheme[name] = options
        end
        runner_options = {}
        (config["#{runner_name}_options"] || {}).each do |key, value|
          key = key.to_sym
          value = ColorScheme[value] if key == :color_scheme
          if key == :arguments
            @default_arguments.concat(value.split)
          else
            runner_options[key] = value
          end
        end
        @runner_options = @runner_options.merge(runner_options)
      end

      private
      def default_runner
        runner = self.class.default_runner
        if ENV["EMACS"] == "t"
          runner ||= self.class.runner(:emacs)
        else
          runner ||= self.class.runner(:console)
        end
        runner
      end

      def default_collector
        self.class.collector(@standalone ? :load : :descendant)
      end

      def global_config_file
        File.expand_path("~/.test-unit.yml")
      rescue ArgumentError
        nil
      end

      def load_global_config
        file = global_config_file
        load_config(file) if file and File.exist?(file)
      end

      def change_work_directory(&block)
        if @workdir
          Dir.chdir(@workdir, &block)
        else
          yield
        end
      end

      def prepare_name(name)
        case name
        when /\A\/(.*)\/([imx]*)\z/
          pattern = $1
          options_raw = $2
          options = 0
          options |= Regexp::IGNORECASE if options_raw.include?("i")
          options |= Regexp::MULTILINE if options_raw.include?("m")
          options |= Regexp::EXTENDED if options_raw.include?("x")
          Regexp.new(pattern, options)
        else
          name
        end
      end

      def match_test_name(test, pattern)
        return true if pattern === test.method_name
        return true if pattern === test.local_name
        if pattern.is_a?(String)
          return true if pattern === "#{test.class}##{test.method_name}"
          return true if pattern === "#{test.class}##{test.local_name}"
        end
        false
      end

      def match_test_case_name(test, pattern)
        test.class.ancestors.each do |test_class|
          break if test_class == TestCase
          return true if pattern === test_class.name
        end
        false
      end

      def add_test_path(path)
        if /:(\d+)\z/ =~ path
          line = $1.to_i
          path = $PREMATCH
          add_location_filter(path, line)
        end
        @to_run << path
      end

      def add_location_filter(path, line)
        @filters << lambda do |test|
          test.class.test_defined?(:path => path,
                                   :line => line,
                                   :method_name => test.method_name)
        end
      end

      class StopOnFailureListener
        def attach_to_mediator(mediator)
          mediator.add_listener(TestResult::FINISHED) do |result|
            result.stop unless result.passed?
          end
        end
      end

      class GCStressListener
        def attach_to_mediator(mediator)
          mediator.add_listener(TestCase::STARTED) do |test|
            GC.start
            GC.stress = true
          end

          mediator.add_listener(TestCase::FINISHED) do |test|
            GC.start
            GC.stress = false
          end
        end
      end
    end
  end
end

require "test/unit/runner/console"
require "test/unit/runner/emacs"
require "test/unit/runner/xml"
test-unit-3.6.2/lib/test/unit/code-snippet-fetcher.rb000066400000000000000000000030061456346657200225400ustar00rootroot00000000000000module Test
  module Unit
    class CodeSnippetFetcher
      def initialize
        @sources = {}
      end

      def fetch(path, line, options={})
        n_context_line = options[:n_context_line] || 3
        lines = source(path)
        return [] if lines.nil?
        min_line = [line - n_context_line, 1].max
        max_line = [line + n_context_line, lines.length].min
        window = min_line..max_line
        window.collect do |n|
          attributes = {:target_line? => (n == line)}
          [n, lines[n - 1].chomp, attributes]
        end
      end

      def source(path)
        @sources[path] ||= read_source(path)
      end

      private
      def read_source(path)
        return nil unless File.exist?(path)
        lines = []
        File.open(path, "rb") do |file|
          first_line = file.gets
          break if first_line.nil?
          encoding = detect_encoding(first_line) || Encoding::UTF_8
          first_line.force_encoding(encoding)
          lines << first_line
          file.each_line do |line|
            line.force_encoding(encoding)
            lines << line
          end
        end
        lines
      end

      def detect_encoding(first_line)
        return nil unless first_line.respond_to?(:ascii_only?)
        return nil unless first_line.ascii_only?
        if /\b(?:en)?coding[:=]\s*([a-z\d_-]+)/i =~ first_line
          begin
            Encoding.find($1)
          rescue ArgumentError
            nil
          end
        else
          nil
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector.rb000066400000000000000000000052661456346657200205300ustar00rootroot00000000000000module Test
  module Unit
    module Collector
      def initialize
        @filters = []
      end

      def filter=(filters)
        @filters = case(filters)
          when Proc
            [filters]
          when Array
            filters
        end
      end

      def add_suite(destination, suite)
        to_delete = suite.tests.find_all do |test|
          test.is_a?(TestCase) and !include?(test)
        end
        suite.delete_tests(to_delete)
        destination << suite unless suite.empty?
      end

      def add_test_cases(suite, test_cases)
        children_map = {}
        test_cases.each do |test_case|
          ancestor_classes = test_case.ancestors.find_all do |ancestor|
            ancestor.is_a?(Class)
          end
          parent = ancestor_classes[1]
          children_map[parent] ||= []
          children_map[parent] << test_case
        end

        root_test_cases = children_map.keys - test_cases
        root_test_cases.each do |root_test_case|
          add_test_case(suite, root_test_case, children_map)
        end
      end

      def include?(test)
        return true if(@filters.empty?)
        @filters.each do |filter|
          return false if filter[test] == false
        end
        true
      end

      def sort(suites)
        suites.sort_by do |suite|
          [suite.priority, suite.name || suite.to_s]
        end
      end

      private
      def add_test_case(suite, test_case, children_map)
        children = children_map[test_case]
        return if children.nil?

        sub_suites = []
        children.each do |child|
          sub_suite = child.suite
          add_test_case(sub_suite, child, children_map)
          add_suite(sub_suites, sub_suite)
        end
        sort(sub_suites).each do |sub_suite|
          suite << sub_suite
        end
      end

      def adjust_ractor_tests(suite)
        return if suite.nil?
        ractor_suites = extract_ractor_tests(suite)
        ractor_suites.each do |ractor_suite|
          suite << ractor_suite
        end
      end

      def extract_ractor_tests(suite)
        ractor_suites = []
        ractor_tests = []
        suite.tests.each do |test|
          case test
          when TestSuite
            ractor_suites.concat(extract_ractor_tests(test))
          else
            next unless test[:ractor]
            ractor_tests << test
          end
        end
        unless ractor_tests.empty?
          suite.delete_tests(ractor_tests)
          ractor_suite = TestSuite.new(suite.name, suite.test_case)
          ractor_tests.each do |ractor_test|
            ractor_suite << ractor_test
          end
          ractor_suites << ractor_suite
        end
        ractor_suites
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector/000077500000000000000000000000001456346657200201725ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/collector/descendant.rb000066400000000000000000000006251456346657200226320ustar00rootroot00000000000000require 'test/unit/collector'

module Test
  module Unit
    module Collector
      class Descendant
        include Collector

        NAME = 'collected from the subclasses of TestCase'

        def collect(name=NAME)
          suite = TestSuite.new(name)
          add_test_cases(suite, TestCase::DESCENDANTS)
          adjust_ractor_tests(suite)
          suite
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector/dir.rb000066400000000000000000000064211456346657200213000ustar00rootroot00000000000000require 'test/unit/testsuite'
require 'test/unit/collector'

module Test
  module Unit
    module Collector
      class Dir
        include Collector

        attr_reader :pattern, :exclude
        attr_accessor :base

        def initialize(dir=::Dir, file=::File, object_space=::ObjectSpace, req=nil)
          super()
          @dir = dir
          @file = file
          @object_space = object_space
          @req = req
          @pattern = [/\btest_.*\.rb\Z/m]
          @exclude = []
          @base = nil
        end

        def collect(*from)
          basedir = @base
          $:.push(basedir) if basedir
          if(from.empty?)
            suite = recursive_collect('.', find_test_cases)
          elsif(from.size == 1)
            suite = recursive_collect(from.first, find_test_cases)
          else
            suites = []
            from.each do |f|
              suite = recursive_collect(f, find_test_cases)
              suites << suite unless(suite.tests.empty?)
            end
            suite = TestSuite.new("[#{from.join(', ')}]")
            sort(suites).each{|s| suite << s}
            suite
          end
          adjust_ractor_tests(suite)
          suite
        ensure
          $:.delete_at($:.rindex(basedir)) if basedir
        end

        def find_test_cases(ignore=[])
          cases = []
          @object_space.each_object(Class) do |c|
            cases << c if(c < TestCase && !ignore.include?(c))
          end
          ignore.concat(cases)
          cases
        end

        def recursive_collect(name, already_gathered)
          sub_suites = []
          path = realdir(name)
          if @file.directory?(path)
            dir_name = name unless name == '.'
            @dir.entries(path).each do |e|
              next if(e == '.' || e == '..')
              e_name = dir_name ? @file.join(dir_name, e) : e
              if @file.directory?(realdir(e_name))
                next if /\A(?:CVS|\.svn|\.git)\z/ =~ e
                sub_suite = recursive_collect(e_name, already_gathered)
                sub_suites << sub_suite unless(sub_suite.empty?)
              else
                next if /~\z/ =~ e_name or /\A\.\#/ =~ e
                if @pattern and !@pattern.empty?
                  next unless @pattern.any? {|pat| pat =~ e_name}
                end
                if @exclude and !@exclude.empty?
                  next if @exclude.any? {|pat| pat =~ e_name}
                end
                collect_file(e_name, sub_suites, already_gathered)
              end
            end
          else
            collect_file(name, sub_suites, already_gathered)
          end
          suite = TestSuite.new(@file.basename(name))
          sort(sub_suites).each{|s| suite << s}
          suite
        end

        def collect_file(name, suites, already_gathered)
          dir = @file.dirname(@file.expand_path(name, @base))
          $:.unshift(dir)
          if(@req)
            @req.require(name)
          else
            require(name)
          end
          find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)}
        ensure
          $:.delete_at($:.rindex(dir)) if(dir)
        end

        def realdir(path)
          if @base
            @file.join(@base, path)
          else
            path
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector/load.rb000066400000000000000000000135401456346657200214410ustar00rootroot00000000000000require 'pathname'

require 'test/unit/testsuite'
require 'test/unit/collector'

module Test
  module Unit
    module Collector
      class Load
        include Collector

        attr_reader :patterns, :excludes, :base
        attr_reader :default_test_paths

        def initialize
          super
          @system_excludes = [/~\z/, /\A\.\#/]
          @system_directory_excludes = [/\A(?:CVS|\.svn|\.git)\z/]
          @patterns = [/\Atest[_\-].+\.rb\z/m, /[_\-]test\.rb\z/]
          @excludes = []
          @base = nil
          @default_test_paths = []
          @require_failed_infos = []
        end

        def base=(base)
          base = Pathname(base) unless base.nil?
          @base = base
        end

        def default_test_paths=(paths)
          @default_test_paths = paths.collect do |path|
            Pathname(path)
          end
        end

        def collect(*froms)
          add_load_path(@base) do
            froms = @default_test_paths if froms.empty?
            froms = ["."] if froms.empty?
            test_suites = []
            already_gathered = {}
            find_test_cases(already_gathered)
            froms.each do |from|
              from = resolve_path(from)
              if from.directory?
                test_suite = collect_recursive(from, already_gathered)
                test_suites << test_suite unless test_suite.tests.empty?
              else
                collect_file(from, test_suites, already_gathered)
              end
            end
            add_require_failed_test_suite(test_suites)

            if test_suites.size > 1
              test_suite = TestSuite.new("[#{froms.join(', ')}]")
              sort(test_suites).each do |sub_test_suite|
                test_suite << sub_test_suite
              end
            else
              test_suite = test_suites.first
            end

            adjust_ractor_tests(test_suite)

            test_suite
          end
        end

        def find_test_cases(already_gathered)
          test_cases = []
          TestCase::DESCENDANTS.each do |test_case|
            next if already_gathered.key?(test_case)
            test_cases << test_case
            already_gathered[test_case] = true
          end
          test_cases
        end

        private
        def collect_recursive(path, already_gathered)
          sub_test_suites = []

          if path.directory?
            directories, files = path.children.partition do |child|
              child.directory?
            end

            files.each do |child|
              next if excluded_file?(child.basename.to_s)
              collect_file(child, sub_test_suites, already_gathered)
            end

            directories.each do |child|
              next if excluded_directory?(child.basename.to_s)
              sub_test_suite = collect_recursive(child, already_gathered)
              sub_test_suites << sub_test_suite unless sub_test_suite.empty?
            end
          else
            unless excluded_file?(path.basename.to_s)
              collect_file(path, sub_test_suites, already_gathered)
            end
          end

          test_suite = TestSuite.new(path.basename.to_s)
          sort(sub_test_suites).each do |sub_test_suite|
            test_suite << sub_test_suite
          end
          test_suite
        end

        def collect_file(path, test_suites, already_gathered)
          @program_file ||= File.expand_path($0)
          expanded_path = path.expand_path
          return if @program_file == expanded_path.to_s
          add_load_path(expanded_path.dirname) do
            begin
              require(expanded_path.to_s)
            rescue LoadError
              @require_failed_infos << {:path => expanded_path, :exception => $!}
            end
            add_test_cases(test_suites, find_test_cases(already_gathered))
          end
        end

        def resolve_path(path)
          if @base
            @base + path
          else
            Pathname(path)
          end
        end

        def add_load_path(path)
          return yield if path.nil?

          path = path.to_s
          begin
            $LOAD_PATH.unshift(path)
            yield
          ensure
            index = $LOAD_PATH.index(path)
            $LOAD_PATH.delete_at(index) if index
          end
        end

        def excluded_directory?(base)
          @system_directory_excludes.any? {|pattern| pattern =~ base}
        end

        def excluded_file?(base)
          return true if @system_excludes.any? {|pattern| pattern =~ base}

          patterns = @patterns || []
          unless patterns.empty?
            return true unless patterns.any? {|pattern| pattern =~ base}
          end

          excludes = @excludes || []
          unless excludes.empty?
            return true if excludes.any? {|pattern| pattern =~ base}
          end

          false
        end

        def add_require_failed_test_suite(test_suites)
          return if @require_failed_infos.empty?

          require_failed_infos = @require_failed_infos
          require_failed_errors = Class.new(Test::Unit::TestCase)
          require_failed_errors.class_eval do
            class << self
              def name
                "RequireFailedErrors"
              end
            end

            require_failed_infos.each do |info|
              path = info[:path]
              normalized_path = path.to_s.gsub(/[^a-z0-9\_]+/i, '_')
              normalized_path = normalized_path.gsub(/\A_+/, '')
              exception = info[:exception]
              define_method("test_require_#{normalized_path}") do
                raise(exception.class,
                      "failed to load <#{path}>: #{exception.message}",
                      exception.backtrace)
              end
            end

            def priority
              100
            end
          end

          add_suite(test_suites, require_failed_errors.suite)
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector/objectspace.rb000066400000000000000000000014701456346657200230030ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/collector'

module Test
  module Unit
    module Collector
      class ObjectSpace
        include Collector

        NAME = 'collected from the ObjectSpace'

        def initialize(source=::ObjectSpace)
          super()
          @source = source
        end

        def collect(name=NAME)
          suite = TestSuite.new(name)
          sub_suites = []
          @source.each_object(Class) do |klass|
            if(Test::Unit::TestCase > klass)
              add_suite(sub_suites, klass.suite)
            end
          end
          sort(sub_suites).each{|s| suite << s}
          adjust_ractor_tests(suite)
          suite
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/collector/xml.rb000066400000000000000000000165041456346657200213250ustar00rootroot00000000000000#--
#
# Author:: Kouhei Sutou
# Copyright::
#   * Copyright (c) 2011 Kouhei Sutou 
# License:: Ruby license.

# just test!!! don't use it yet!!!

require 'test/unit/collector'

require 'rexml/document'
require 'rexml/streamlistener'

module Test
  module Unit
    module Collector
      class XML
        include Collector

        def collect(xml_log_path)
          listener = Listener.new
          File.open(xml_log_path) do |xml_log|
            parser = REXML::Parsers::StreamParser.new(xml_log, listener)
            parser.parse
          end
          suite = TestSuite.new("tests in #{xml_log_path}")
          suites = listener.test_suites
          sort(suites).each {|s| add_suite(suite, s)}
          suite
        end

        class Listener
          include REXML::StreamListener

          attr_reader :test_suites
          def initialize
            @ns_stack = [{"xml" => :xml}]
            @tag_stack = [["", :root]]
            @text_stack = ['']
            @state_stack = [:root]
            @values = {}
            @test_suites = []
          end

          def tag_start(name, attributes)
            @text_stack.push('')

            ns = @ns_stack.last.dup
            attrs = {}
            attributes.each do |n, v|
              if /\Axmlns(?:\z|:)/ =~ n
                ns[$POSTMATCH] = v
              else
                attrs[n] = v
              end
            end
            @ns_stack.push(ns)

            _parent_tag = parent_tag
            prefix, local = split_name(name)
            uri = _ns(ns, prefix)
            @tag_stack.push([uri, local])

            state = next_state(@state_stack.last, uri, local)
            @state_stack.push(state)
            @values = {}
            case state
            when :test_suite, :test_case
              # do nothing
            when :test
              @n_pass_assertions = 0 if _parent_tag == "start-test"
            when :backtrace
              @backtrace = []
              @values_backup = @values
            end
          end

          def tag_end(name)
            state = @state_stack.pop
            text = @text_stack.pop
            uri, local = @tag_stack.pop
            no_action_states = [:root, :stream]
            case state
            when *no_action_states
              # do nothing
            when :test_suite
              test_suite_end
            when :complete_test_case
              @test_suites.last << @test_case.suite
            when :test_case
              test_case_end
            when :result
              @result = @values
            when :test
              test_end
            when :pass_assertion
              @n_pass_assertions += 1
            when :backtrace
              @values = @values_backup
              @values["backtrace"] = @backtrace
            when :entry
              file = @values['file']
              line = @values['line']
              info = @values['info']
              @backtrace << "#{file}:#{line}: #{info}"
              @values = {}
            else
              local = normalize_local(local)
              @values[local] = text
            end
            @ns_stack.pop
          end

          def text(data)
            @text_stack.last << data
          end

          private
          def _ns(ns, prefix)
            ns.fetch(prefix, "")
          end

          NAME_SPLIT = /^(?:([\w:][-\w\d.]*):)?([\w:][-\w\d.]*)/
          def split_name(name)
            name =~ NAME_SPLIT
            [$1 || '', $2]
          end

          STATE_TABLE = {
            :root => [:stream],
            :stream => [:ready_test_suite,
                        :start_test_suite,
                        :ready_test_case,
                        :start_test_case,
                        :start_test,
                        :pass_assertion,
                        :test_result,
                        :complete_test,
                        :complete_test_case,
                        :complete_test_suite,
                        :success],
            :ready_test_suite => [:n_tests],
            :start_test_suite => [:test_suite],
            :ready_test_case => [:test_case,
                                 :n_tests],
            :start_test_case => [:test_case],
            :start_test => [:test],
            :pass_assertion => [:test],
            :complete_test => [:test, :success],
            :complete_test_case => [:test_case,
                                    :elapsed,
                                    :success],
            :complete_test_suite => [:test_suite,
                                     :success],
            :test_suite => [:start_time,
                            :elapsed],
            :test_case => [:name,
                           :start_time,
                           :elapsed],
            :test => [:name,
                      :start_time,
                      :elapsed],
            :test_result => [:test,
                             :result],
            :result => [:test_case,
                        :test,
                        :status,
                        :backtrace,
                        :detail],
            :backtrace => [:entry],
            :entry => [:file,
                       :line,
                       :info],
          }
          def next_state(current_state, uri, local)
            local = normalize_local(local)
            valid_elements = STATE_TABLE[current_state]
            if valid_elements.nil?
              raise "unexpected element: #{current_path}"
            end
            next_state = local.to_sym
            unless valid_elements.include?(next_state)
              raise "unexpected element: #{current_path}"
            end
            next_state
          end

          def current_path
            locals = @tag_stack.collect do |uri, local|
              local
            end
            ["", *locals].join("/")
          end

          def normalize_local(local)
            local.gsub(/-/, "_")
          end

          def parent_tag
            @tag_stack.last[1]
          end

          def test_suite_end
            return unless parent_tag == "start-test-suite"
            suite = TestSuite.new
            ["start_time", "elapsed_time", "n_tests"].each do |key|
              if @values.has_key?(key)
                suite.instance_variable_set("@#{key}", @values[key])
              end
            end
            @test_suites << suite
          end

          def test_case_end
            return unless parent_tag == "start-test-case"
            name = @values["name"]
            @test_case = Class.new(TestCase) do
              define_method(:name) do
                name
              end
            end
          end

          def test_end
            return unless parent_tag == "complete-test"
            name = @values["name"]
            n_pass_assertions = @n_pass_assertions
            result = @result
            @test_case.module_eval do
              test
              define_method(name) do
                n_pass_assertions.times do
                  add_assertion
                end
                case result["status"]
                when "omission"
                  add_omission(Omission.new(name,
                                            result["backtrace"],
                                            result["detail"]))
                end
              end
            end
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/color-scheme.rb000066400000000000000000000173251456346657200211210ustar00rootroot00000000000000require 'test/unit/color'

module Test
  module Unit
    class ColorScheme
      include Enumerable

      TERM_256 = /
        [+-]256color|
        \A(?:
          alacritty|
          iTerm\s?\d*\.app|
          kitty|
          mintty|
          ms-terminal|
          nsterm-build\d+|
          nsterm|
          terminator|
          terminology(?:-[0-9.]+)?|
          termite|
          vscode
        )\z/x

      class << self
        def default
          if available_colors >= 256
            default_for_256_colors
          else
            default_for_8_colors
          end
        end

        @@default_for_8_colors = nil
        def default_for_8_colors
          @@default_for_8_colors ||=
            new("pass" => Color.new("green", :background => true) +
                          Color.new("white", :bold => true),
                "pass-marker" => Color.new("green", :bold => true),
                "failure" => Color.new("red", :background => true) +
                             Color.new("white", :bold => true),
                "failure-marker" => Color.new("red"),
                "pending" => Color.new("magenta", :background => true) +
                             Color.new("white", :bold => true),
                "pending-marker" => Color.new("magenta"),
                "omission" => Color.new("blue", :background => true) +
                             Color.new("white", :bold => true),
                "omission-marker" => Color.new("blue"),
                "notification" => Color.new("cyan", :background => true) +
                                  Color.new("white", :bold => true),
                "notification-marker" => Color.new("cyan"),
                "error" => Color.new("black", :background => true) +
                           Color.new("yellow", :bold => true),
                "error-marker" => Color.new("yellow"),
                "case" => Color.new("blue", :background => true) +
                          Color.new("white", :bold => true),
                "suite" => Color.new("green", :background => true) +
                           Color.new("white", :bold => true),
                "diff-inserted-tag" => Color.new("red", :background => true) +
                                       Color.new("black", :bold => true),
                "diff-deleted-tag" => Color.new("green", :background => true) +
                                      Color.new("black", :bold => true),
                "diff-difference-tag" => Color.new("cyan", :background => true) +
                                         Color.new("white", :bold => true),
                "diff-inserted" => Color.new("red", :background => true) +
                                   Color.new("white", :bold => true),
                "diff-deleted" =>  Color.new("green", :background => true) +
                                   Color.new("white", :bold => true))
        end

        @@default_for_256_colors = nil
        def default_for_256_colors
          @@default_for_256_colors ||=
            new("pass" => Color.new("030", :background => true) +
                          Color.new("555", :bold => true),
                "pass-marker" => Color.new("050", :bold => true),
                "failure" => Color.new("300", :background => true) +
                             Color.new("555", :bold => true),
                "failure-marker" => Color.new("500"),
                "pending" => Color.new("303", :background => true) +
                              Color.new("555", :bold => true),
                "pending-marker" => Color.new("303"),
                "omission" => Color.new("001", :background => true) +
                              Color.new("555", :bold => true),
                "omission-marker" => Color.new("001"),
                "notification" => Color.new("011", :background => true) +
                                  Color.new("555", :bold => true),
                "notification-marker" => Color.new("011"),
                "error" => Color.new("000", :background => true) +
                           Color.new("550", :bold => true),
                "error-marker" => Color.new("550"),
                "case" => Color.new("220", :background => true) +
                          Color.new("555", :bold => true),
                "suite" => Color.new("110", :background => true) +
                           Color.new("555", :bold => true),
                "diff-inserted-tag" => Color.new("500", :background => true) +
                                       Color.new("000", :bold => true),
                "diff-deleted-tag" => Color.new("050", :background => true) +
                                      Color.new("000", :bold => true),
                "diff-difference-tag" => Color.new("005", :background => true) +
                                         Color.new("555", :bold => true),
                "diff-inserted" => Color.new("300", :background => true) +
                                   Color.new("555", :bold => true),
                "diff-deleted" =>  Color.new("030", :background => true) +
                                   Color.new("555", :bold => true))
        end

        @@schemes = {}
        def all
          @@schemes.merge("default" => default)
        end

        def [](id)
          @@schemes[id.to_s]
        end

        def []=(id, scheme_or_spec)
          if scheme_or_spec.is_a?(self)
            scheme = scheme_or_spec
          else
            scheme = new(scheme_or_spec)
          end
          @@schemes[id.to_s] = scheme
        end

        def available_colors
          guess_available_colors_from_vte_version_env ||
            guess_available_colors_from_colorterm_env ||
            guess_available_colors_from_term_env ||
            guess_available_colors_from_github_actions_env ||
            8
        end

        private
        def guess_available_colors_from_vte_version_env
          vte_version = ENV["VTE_VERSION"]
          return nil if vte_version.nil?

          major = 0
          minor = 13
          micro = 0
          packed_version = major * 10000 + minor * 100 + micro
          if vte_version.to_i >= packed_version
            256
          else
            8
          end
        end

        def guess_available_colors_from_colorterm_env
          case ENV["COLORTERM"]
          when "gnome-terminal", "xfce4-terminal"
            256
          else
            nil
          end
        end

        def guess_available_colors_from_term_env
          case ENV["TERM"]
          when /[+-]direct/
            2 ** 24
          when TERM_256
            256
          else
            nil
          end
        end

        def guess_available_colors_from_github_actions_env
          if ENV["GITHUB_ACTIONS"] == "true"
            2 ** 24
          else
            nil
          end
        end
      end

      def initialize(scheme_spec)
        @scheme = {}
        scheme_spec.each do |key, color_spec|
          self[key] = color_spec
        end
      end

      def [](name)
        @scheme[name.to_s]
      end

      def []=(name, color_spec)
        @scheme[name.to_s] = make_color(color_spec)
      end

      def each(&block)
        @scheme.each(&block)
      end

      def to_hash
        hash = {}
        @scheme.each do |key, color|
          hash[key] = color
        end
        hash
      end

      private
      def make_color(color_spec)
        if color_spec.is_a?(Color) or color_spec.is_a?(MixColor)
          color_spec
        else
          color_name = nil
          normalized_color_spec = {}
          color_spec.each do |key, value|
            key = key.to_sym
            if key == :name
              color_name = value
            else
              normalized_color_spec[key] = value
            end
          end
          Color.new(color_name, normalized_color_spec)
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/color.rb000066400000000000000000000057161456346657200176600ustar00rootroot00000000000000module Test
  module Unit
    class Color
      class Error < StandardError
      end

      class ParseError < Error
      end

      class << self
        def parse_256_color(string)
          case string
          when /\A([0-5])([0-5])([0-5])\z/
            red, green, blue = $1, $2, $3
            red.to_i * 36 + green.to_i * 6 + blue.to_i + 16
          else
            message = "must be 'RGB' format and R, G and B " +
              "are in 0-5: #{string.inspect}"
            raise ParseError, message
          end
        end
      end

      NAMES = ["black", "red", "green", "yellow",
               "blue", "magenta", "cyan", "white"]

      attr_reader :name
      def initialize(name, options={})
        @name = name
        if options.has_key?(:foreground)
          if options[:foreground].nil?
            @background = false
          else
            @background = !options[:foreground]
          end
        else
          @background = options[:background]
        end
        @intensity = options[:intensity]
        @bold = options[:bold]
        @italic = options[:italic]
        @underline = options[:underline]
      end

      def foreground?
        not background?
      end

      def background?
        @background
      end

      def intensity?
        @intensity
      end

      def bold?
        @bold
      end

      def italic?
        @italic
      end

      def underline?
        @underline
      end

      def ==(other)
        self.class === other and
          [name, background?, intensity?,
           bold?, italic?, underline?] ==
          [other.name, other.background?, other.intensity?,
           other.bold?, other.italic?, other.underline?]
      end

      def sequence
        sequence = []
        if @name == "none"
        elsif @name == "reset"
          sequence << "0"
        else
          if NAMES.include?(@name)
            color_parameter = foreground? ? 3 : 4
            color_parameter += 6 if intensity?
            color = NAMES.index(@name)
            sequence << "#{color_parameter}#{color}"
          else
            sequence << (foreground? ? "38" : "48")
            sequence << "5"
            sequence << self.class.parse_256_color(@name).to_s
          end
        end
        sequence << "1" if bold?
        sequence << "3" if italic?
        sequence << "4" if underline?
        sequence
      end

      def escape_sequence
        "\e[#{sequence.join(';')}m"
      end

      def +(other)
        MixColor.new([self, other])
      end
    end

    class MixColor
      attr_reader :colors
      def initialize(colors)
        @colors = colors
      end

      def sequence
        @colors.inject([]) do |result, color|
          result + color.sequence
        end
      end

      def escape_sequence
        "\e[#{sequence.join(';')}m"
      end

      def +(other)
        self.class.new([self, other])
      end

      def ==(other)
        self.class === other and colors == other.colors
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/data-sets.rb000066400000000000000000000063211456346657200204200ustar00rootroot00000000000000module Test
  module Unit
    class DataSets
      def initialize
        @variables = []
        @procs = []
        @value_sets = []
      end

      def add(data_set, options=nil)
        options ||= {}
        if data_set.respond_to?(:call)
          @procs << [data_set, options]
        elsif data_set.is_a?(Array)
          @variables << [data_set, options]
        else
          @value_sets << [data_set, options]
        end
      end

      def <<(data_set)
        add(data_set)
      end

      def have_keep?
        each_data_set do |_, options|
          return true if options[:keep]
        end
        false
      end

      def keep
        new_data_sets = self.class.new
        each_data_set do |data_set, options|
          next if options.nil?
          next unless options[:keep]
          new_data_sets.add(data_set, options)
        end
        new_data_sets
      end

      def each
        variables = @variables
        value_sets = @value_sets
        @procs.each do |proc, options|
          data_set = proc.call
          case data_set
          when Array
            variables += [[data_set, options]]
          else
            value_sets += [[data_set, options]]
          end
        end

        value_sets.each do |values, _options|
          values.each do |label, data|
            yield(label, data)
          end
        end

        each_pattern(variables) do |label, data|
          yield(label, data)
        end
      end

      def ==(other)
        @variables == other.instance_variable_get(:@variables) and
          @procs == other.instance_variable_get(:@procs) and
          @value_sets == other.instance_variable_get(:@value_sets)
      end

      def eql?(other)
        self == other
      end

      def hash
        [@variables, @procs, @value_sets].hash
      end

      private
      def each_data_set(&block)
        @procs.each(&block)
        @variables.each(&block)
        @value_sets.each(&block)
      end

      def each_pattern(variables)
        grouped_variables = variables.group_by do |_, options|
          options[:group]
        end
        grouped_variables.each do |group, group_variables|
          each_raw_pattern(group_variables) do |cell|
            label = String.new
            label << "group: #{group.inspect}" unless group.nil?
            data = {}
            cell.each do |variable, pattern, pattern_label|
              label << ", " unless label.empty?
              label << "#{variable}: #{pattern_label}"
              data[variable] = pattern
            end
            yield(label, data)
          end
        end
      end

      def each_raw_pattern(variables, &block)
        return if variables.empty?

        sorted_variables = variables.sort_by do |(variable, _), _|
          variable
        end
        all_patterns = sorted_variables.collect do |(variable, patterns), _|
          if patterns.is_a?(Hash)
            patterns.collect do |pattern_label, pattern|
              [variable, pattern, pattern_label]
            end
          else
            patterns.collect do |pattern|
              [variable, pattern, pattern.inspect]
            end
          end
        end
        all_patterns[0].product(*all_patterns[1..-1], &block)
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/data.rb000066400000000000000000000310251456346657200174430ustar00rootroot00000000000000require "test/unit/data-sets"

module Test
  module Unit
    module Data
      class << self
        def included(base)
          base.extend(ClassMethods)
        end
      end

      module ClassMethods
        # This method provides Data-Driven-Test functionality.
        #
        # Define test data in the test code.
        #
        # @overload data(label, data, options={})
        #   @param [String] label specify test case name.
        #   @param data specify test data.
        #   @param [Hash] options specify options.
        #   @option options [Boolean] :keep whether or not to use
        #     this data in the following test methods
        #
        #   @example data(label, data)
        #     data("empty string", [true, ""])
        #     data("plain string", [false, "hello"])
        #     def test_empty?(data)
        #       expected, target = data
        #       assert_equal(expected, target.empty?)
        #     end
        #
        # @overload data(variable, patterns, options={})
        #   @param [Symbol] variable specify test pattern variable name.
        #   @param [Array] patterns specify test patterns for the variable.
        #   @param [Hash] options specify options.
        #   @option options [Boolean] :keep whether or not to use
        #     this data in the following test methods
        #   @option options [Object] :group the test pattern group.
        #     Test matrix is generated for each test pattern group separately.
        #
        #   @example data(variable, patterns)
        #     data(:x, [1, 2, 3])
        #     data(:y, ["a", "b"])
        #     def test_patterns(data)
        #       # 3 * 2 times executed
        #       # 3: the number of patterns of :x
        #       # 2: the number of patterns of :y
        #       p data
        #         # => {:x => 1, :y => "a"}
        #         # => {:x => 1, :y => "b"}
        #         # => {:x => 2, :y => "a"}
        #         # => {:x => 2, :y => "b"}
        #         # => {:x => 3, :y => "a"}
        #         # => {:x => 3, :y => "b"}
        #     end
        #
        #   Generates test matrix from variable and patterns pairs.
        #
        # @overload data(data_set, options={})
        #   @param [Hash] data_set specify test data as a Hash that
        #     key is test label and value is test data.
        #   @param [Hash] options specify options.
        #   @option options [Boolean] :keep whether or not to use
        #     this data in the following test methods
        #
        #   @example data(data_set)
        #     data("empty string" => [true, ""],
        #          "plain string" => [false, "hello"])
        #     def test_empty?(data)
        #       expected, target = data
        #       assert_equal(expected, target.empty?)
        #     end
        #
        # @overload data(options={}, &block)
        #   @param [Hash] options specify options.
        #   @option options [Boolean] :keep whether or not to use
        #     this data in the following test methods
        #   @yieldreturn [Hash] return test data set
        #     as a Hash that key is test label and value is test data.
        #
        #   @example data(&block)
        #     data do
        #       data_set = {}
        #       data_set["empty string"] = [true, ""]
        #       data_set["plain string"] = [false, "hello"]
        #       data_set
        #     end
        #     def test_empty?(data)
        #       expected, target = data
        #       assert_equal(expected, target.empty?)
        #     end
        #
        # @overload data(options={}, &block)
        #   @param [Hash] options specify options.
        #   @option options [Boolean] :keep whether or not to use
        #     this data in the following test methods
        #   @yieldreturn [Array] return test data set
        #     as an Array of variable and patterns.
        #
        #   @example data(&block)
        #     data do
        #       patterns = 3.times.to_a
        #       [:x, patterns]
        #     end
        #     data do
        #       patterns = []
        #       character = "a"
        #       2.times.each do
        #         patterns << character
        #         character = character.succ
        #       end
        #       [:y, patterns]
        #     end
        #     def test_patterns(data)
        #       # 3 * 2 times executed
        #       # 3: the number of patterns of :x
        #       # 2: the number of patterns of :y
        #       p data
        #         # => {:x => 0, :y => "a"}
        #         # => {:x => 0, :y => "b"}
        #         # => {:x => 1, :y => "a"}
        #         # => {:x => 1, :y => "b"}
        #         # => {:x => 2, :y => "a"}
        #         # => {:x => 2, :y => "b"}
        #     end
        #
        #   Generates test matrix from variable and patterns pairs.
        #
        def data(*arguments, &block)
          options = nil
          n_arguments = arguments.size
          case n_arguments
          when 0
            raise ArgumentError, "no block is given" unless block_given?
            data_set = block
          when 1
            if block_given?
              data_set = block
              options = arguments[0]
            else
              data_set = arguments[0]
            end
          when 2
            case arguments[0]
            when String
              data_set = {arguments[0] => arguments[1]}
            when Hash
              data_set = arguments[0]
              options = arguments[1]
            else
              variable = arguments[0]
              patterns = arguments[1]
              data_set = [variable, patterns]
            end
          when 3
            case arguments[0]
            when String
              data_set = {arguments[0] => arguments[1]}
              options = arguments[2]
            else
              variable = arguments[0]
              patterns = arguments[1]
              data_set = [variable, patterns]
              options = arguments[2]
            end
          else
            message = "wrong number arguments(#{n_arguments} for 0..3)"
            raise ArgumentError, message
          end
          options ||= {}
          data_sets = current_attribute(:data)[:value] || DataSets.new
          data_sets.add(data_set, options)
          if options[:keep] or data_sets.have_keep?
            keep_hook = lambda do |attr|
              attr.merge(value: attr[:value].keep)
            end
            options = options.merge(keep: true, keep_hook: keep_hook)
          end
          attribute(:data, data_sets, options)
        end

        # This method provides Data-Driven-Test functionality.
        #
        # Load test data from the file. This is shorthand to load
        # test data from file.  If you want to load complex file, you
        # can use {#data} with block.
        #
        # @param [String] file_name full path to test data file.
        #   File format is automatically detected from filename extension.
        # @raise [ArgumentError] if `file_name` is not supported file format.
        # @see Loader#load
        #
        # @example Load data from CSV file
        #   load_data("/path/to/test-data.csv")
        #   def test_empty?(data)
        #     assert_equal(data["expected"], data["target"].empty?)
        #   end
        #
        def load_data(file_name)
          loader = Loader.new(self)
          loader.load(file_name)
        end

        class Loader
          # @api private
          def initialize(test_case)
            @test_case = test_case
          end

          # Load data from file.
          #
          # @param [String] file_name full path to test data file.
          #   File format is automatically detected from filename extension.
          # @raise [ArgumentError] if `file_name` is not supported file format.
          # @see #load_csv
          # @see #load_tsv
          # @api private
          def load(file_name)
            case File.extname(file_name).downcase
            when ".csv"
              load_csv(file_name)
            when ".tsv"
              load_tsv(file_name)
            else
              raise ArgumentError, "unsupported file format: <#{file_name}>"
            end
          end

          # Load data from CSV file.
          #
          # There are 2 types of CSV file as following examples.
          # First, there is a header on first row and it's first column is "label".
          # Another, there is no header in the file.
          #
          # @example Load data from CSV file with header
          #   # test-data.csv:
          #   #  label,expected,target
          #   #  empty string,true,""
          #   #  plain string,false,hello
          #   #
          #   load_data("/path/to/test-data.csv")
          #   def test_empty?(data)
          #     assert_equal(data["expected"], data["target"].empty?)
          #   end
          #
          # @example Load data from CSV file without header
          #   # test-data-without-header.csv:
          #   #  empty string,true,""
          #   #  plain string,false,hello
          #   #
          #   load_data("/path/to/test-data-without-header.csv")
          #   def test_empty?(data)
          #     expected, target = data
          #     assert_equal(expected, target.empty?)
          #   end
          #
          # @api private
          def load_csv(file_name)
            require 'csv'
            first_row = true
            header = nil
            CSV.foreach(file_name) do |row|
              if first_row
                first_row = false
                if row.first == "label"
                  header = row[1..-1]
                  next
                end
              end

              set_test_data(header, row)
            end
          end

          # Load data from TSV file.
          #
          # There are 2 types of TSV file as following examples.
          # First, there is a header on first row and it's first column is "label".
          # Another, there is no header in the file.
          #
          # @example Load data from TSV file with header
          #   # test-data.tsv:
          #   #  label	expected	target
          #   #  empty string	true	""
          #   #  plain string	false	hello
          #   #
          #   load_data("/path/to/test-data.tsv")
          #   def test_empty?(data)
          #     assert_equal(data["expected"], data["target"].empty?)
          #   end
          #
          # @example Load data from TSV file without header
          #   # test-data-without-header.tsv:
          #   #  empty string	true	""
          #   #  plain string	false	hello
          #   #
          #   load_data("/path/to/test-data-without-header.tsv")
          #   def test_empty?(data)
          #     expected, target = data
          #     assert_equal(expected, target.empty?)
          #   end
          #
          # @api private
          def load_tsv(file_name)
            require "csv"
            if CSV.const_defined?(:VERSION)
              first_row = true
              header = nil
              CSV.foreach(file_name, :col_sep => "\t") do |row|
                if first_row
                  first_row = false
                  if row.first == "label"
                    header = row[1..-1]
                    next
                  end
                end

                set_test_data(header, row)
              end
            else
              # for old CSV library
              first_row = true
              header = nil
              CSV.open(file_name, "r", "\t") do |row|
                if first_row
                  first_row = false
                  if row.first == "label"
                    header = row[1..-1]
                    next
                  end
                end

                set_test_data(header, row)
              end
            end
          end

          private
          def normalize_value(value)
            return true if value == "true"
            return false if value == "false"
            begin
              Integer(value)
            rescue ArgumentError
              begin
                Float(value)
              rescue ArgumentError
                value
              end
            end
          end

          def set_test_data(header, row)
            label = row.shift
            if header
              data = {}
              header.each_with_index do |key, i|
                data[key] = normalize_value(row[i])
              end
            else
              data = row.collect do |cell|
                normalize_value(cell)
              end
            end
            @test_case.data(label, data)
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/diff.rb000066400000000000000000000625621456346657200174540ustar00rootroot00000000000000# port of Python's difflib.
#
# Copyright (c) 2001-2008 Python Software Foundation; All Rights Reserved
# Copyright (c) 2008-2011 Kouhei Sutou; All Rights Reserved
#
# It is free software, and is distributed under (the new Ruby license
# or BSDL) and the PSF license.

module Test
  module Unit
    module Diff
      class SequenceMatcher
        def initialize(from, to, &junk_predicate)
          @from = from
          @to = to
          @junk_predicate = junk_predicate
          update_to_indexes
        end

        def longest_match(from_start, from_end, to_start, to_end)
          best_info = find_best_match_position(from_start, from_end,
                                               to_start, to_end)
          unless @junks.empty?
            args = [from_start, from_end, to_start, to_end]
            best_info = adjust_best_info_with_junk_predicate(false, best_info,
                                                             *args)
            best_info = adjust_best_info_with_junk_predicate(true, best_info,
                                                             *args)
          end

          best_info
        end

        def blocks
          @blocks ||= compute_blocks
        end

        def operations
          @operations ||= compute_operations
        end

        def grouped_operations(context_size=nil)
          context_size ||= 3
          _operations = operations.dup
          _operations = [[:equal, 0, 0, 0, 0]] if _operations.empty?
          expand_edge_equal_operations!(_operations, context_size)

          group_window = context_size * 2
          groups = []
          group = []
          _operations.each do |tag, from_start, from_end, to_start, to_end|
            if tag == :equal and from_end - from_start > group_window
              group << [tag,
                        from_start,
                        [from_end, from_start + context_size].min,
                        to_start,
                        [to_end, to_start + context_size].min]
              groups << group
              group = []
              from_start = [from_start, from_end - context_size].max
              to_start = [to_start, to_end - context_size].max
            end
            group << [tag, from_start, from_end, to_start, to_end]
          end
          groups << group unless group.empty?
          groups
        end

        def ratio
          @ratio ||= compute_ratio
        end

        private
        def update_to_indexes
          @to_indexes = {}
          @junks = {}
          if @to.is_a?(String)
            each = " "[0].is_a?(Integer) ? :each_byte : :each_char
          else
            each = :each
          end
          i = 0
          @to.__send__(each) do |item|
            @to_indexes[item] ||= []
            @to_indexes[item] << i
            i += 1
          end

          return if @junk_predicate.nil?
          @to_indexes = @to_indexes.reject do |key, value|
            junk = @junk_predicate.call(key)
            @junks[key] = true if junk
            junk
          end
        end

        def find_best_match_position(from_start, from_end, to_start, to_end)
          best_from, best_to, best_size = from_start, to_start, 0
          sizes = {}
          from_start.upto(from_end) do |from_index|
            _sizes = {}
            (@to_indexes[@from[from_index]] || []).each do |to_index|
              next if to_index < to_start
              break if to_index > to_end
              size = _sizes[to_index] = (sizes[to_index - 1] || 0) + 1
              if size > best_size
                best_from = from_index - size + 1
                best_to = to_index - size + 1
                best_size = size
              end
            end
            sizes = _sizes
          end
          [best_from, best_to, best_size]
        end

        def adjust_best_info_with_junk_predicate(should_junk, best_info,
                                                 from_start, from_end,
                                                 to_start, to_end)
          best_from, best_to, best_size = best_info
          while best_from > from_start and best_to > to_start and
              (should_junk ?
               @junks.has_key?(@to[best_to - 1]) :
               !@junks.has_key?(@to[best_to - 1])) and
              @from[best_from - 1] == @to[best_to - 1]
            best_from -= 1
            best_to -= 1
            best_size += 1
          end

          while best_from + best_size < from_end and
              best_to + best_size < to_end and
              (should_junk ?
               @junks.has_key?(@to[best_to + best_size]) :
               !@junks.has_key?(@to[best_to + best_size])) and
              @from[best_from + best_size] == @to[best_to + best_size]
            best_size += 1
          end

          [best_from, best_to, best_size]
        end

        def matches
          @matches ||= compute_matches
        end

        def compute_matches
          matches = []
          queue = [[0, @from.size, 0, @to.size]]
          until queue.empty?
            from_start, from_end, to_start, to_end = queue.pop
            match = longest_match(from_start, from_end - 1, to_start, to_end - 1)
            match_from_index, match_to_index, size = match
            unless size.zero?
              if from_start < match_from_index and
                  to_start < match_to_index
                queue.push([from_start, match_from_index,
                            to_start, match_to_index])
              end
              matches << match
              if match_from_index + size < from_end and
                  match_to_index + size < to_end
                queue.push([match_from_index + size, from_end,
                            match_to_index + size, to_end])
              end
            end
          end
          matches.sort_by do |(from_index, _, _)|
            from_index
          end
        end

        def compute_blocks
          blocks = []
          current_from_index = current_to_index = current_size = 0
          matches.each do |from_index, to_index, size|
            if current_from_index + current_size == from_index and
                current_to_index + current_size == to_index
              current_size += size
            else
              unless current_size.zero?
                blocks << [current_from_index, current_to_index, current_size]
              end
              current_from_index = from_index
              current_to_index = to_index
              current_size = size
            end
          end
          unless current_size.zero?
            blocks << [current_from_index, current_to_index, current_size]
          end

          blocks << [@from.size, @to.size, 0]
          blocks
        end

        def compute_operations
          from_index = to_index = 0
          operations = []
          blocks.each do |match_from_index, match_to_index, size|
            tag = determine_tag(from_index, to_index,
                                match_from_index, match_to_index)
            if tag != :equal
              operations << [tag,
                             from_index, match_from_index,
                             to_index, match_to_index]
            end

            from_index, to_index = match_from_index + size, match_to_index + size
            if size > 0
              operations << [:equal,
                             match_from_index, from_index,
                             match_to_index, to_index]
            end
          end
          operations
        end

        def compute_ratio
          matches = blocks.inject(0) {|result, block| result + block[-1]}
          length = @from.length + @to.length
          if length.zero?
            1.0
          else
            2.0 * matches / length
          end
        end

        def determine_tag(from_index, to_index,
                          match_from_index, match_to_index)
          if from_index < match_from_index and to_index < match_to_index
            :replace
          elsif from_index < match_from_index
            :delete
          elsif to_index < match_to_index
            :insert
          else
            :equal
          end
        end

        def expand_edge_equal_operations!(_operations, context_size)
          tag, from_start, from_end, to_start, to_end = _operations[0]
          if tag == :equal
            _operations[0] = [tag,
                              [from_start, from_end - context_size].max,
                              from_end,
                              [to_start, to_end - context_size].max,
                              to_end]
          end

          tag, from_start, from_end, to_start, to_end = _operations[-1]
          if tag == :equal
            _operations[-1] = [tag,
                               from_start,
                               [from_end, from_start + context_size].min,
                               to_start,
                               [to_end, to_start + context_size].min]
          end
        end
      end

      class Differ
        def initialize(from, to)
          @from = from
          @to = to
        end

        private
        def tag(mark, contents)
          contents.collect {|content| mark + content}
        end
      end

      class UTF8Line
        class << self
          # from http://unicode.org/reports/tr11/
          WIDE_CHARACTERS =
            [0x1100..0x1159, 0x115F..0x115F, 0x2329..0x232A,
             0x2E80..0x2E99, 0x2E9B..0x2EF3, 0x2F00..0x2FD5,
             0x2FF0..0x2FFB, 0x3000..0x303E, 0x3041..0x3096,
             0x3099..0x30FF, 0x3105..0x312D, 0x3131..0x318E,
             0x3190..0x31B7, 0x31C0..0x31E3, 0x31F0..0x321E,
             0x3220..0x3243, 0x3250..0x32FE, 0x3300..0x4DB5,
             0x4E00..0x9FC3, 0xA000..0xA48C, 0xA490..0xA4C6,
             0xAC00..0xD7A3, 0xF900..0xFA2D, 0xFA30..0xFA6A,
             0xFA70..0xFAD9, 0xFE10..0xFE19, 0xFE30..0xFE52,
             0xFE54..0xFE66, 0xFE68..0xFE6B, 0xFF01..0xFF60,
             0xFFE0..0xFFE6, 0x20000..0x2FFFD, 0x30000..0x3FFFD,
            ]

          AMBIGUOUS =
            [0x00A1..0x00A1, 0x00A4..0x00A4, 0x00A7..0x00A8,
             0x00AA..0x00AA, 0x00AD..0x00AE, 0x00B0..0x00B4,
             0x00B6..0x00BA, 0x00BC..0x00BF, 0x00C6..0x00C6,
             0x00D0..0x00D0, 0x00D7..0x00D8, 0x00DE..0x00E1,
             0x00E6..0x00E6, 0x00E8..0x00EA, 0x00EC..0x00ED,
             0x00F0..0x00F0, 0x00F2..0x00F3, 0x00F7..0x00FA,
             0x00FC..0x00FC, 0x00FE..0x00FE, 0x0101..0x0101,
             0x0111..0x0111, 0x0113..0x0113, 0x011B..0x011B,
             0x0126..0x0127, 0x012B..0x012B, 0x0131..0x0133,
             0x0138..0x0138, 0x013F..0x0142, 0x0144..0x0144,
             0x0148..0x014B, 0x014D..0x014D, 0x0152..0x0153,
             0x0166..0x0167, 0x016B..0x016B, 0x01CE..0x01CE,
             0x01D0..0x01D0, 0x01D2..0x01D2, 0x01D4..0x01D4,
             0x01D6..0x01D6, 0x01D8..0x01D8, 0x01DA..0x01DA,
             0x01DC..0x01DC, 0x0251..0x0251, 0x0261..0x0261,
             0x02C4..0x02C4, 0x02C7..0x02C7, 0x02C9..0x02CB,
             0x02CD..0x02CD, 0x02D0..0x02D0, 0x02D8..0x02DB,
             0x02DD..0x02DD, 0x02DF..0x02DF, 0x0300..0x036F,
             0x0391..0x03A1, 0x03A3..0x03A9, 0x03B1..0x03C1,
             0x03C3..0x03C9, 0x0401..0x0401, 0x0410..0x044F,
             0x0451..0x0451, 0x2010..0x2010, 0x2013..0x2016,
             0x2018..0x2019, 0x201C..0x201D, 0x2020..0x2022,
             0x2024..0x2027, 0x2030..0x2030, 0x2032..0x2033,
             0x2035..0x2035, 0x203B..0x203B, 0x203E..0x203E,
             0x2074..0x2074, 0x207F..0x207F, 0x2081..0x2084,
             0x20AC..0x20AC, 0x2103..0x2103, 0x2105..0x2105,
             0x2109..0x2109, 0x2113..0x2113, 0x2116..0x2116,
             0x2121..0x2122, 0x2126..0x2126, 0x212B..0x212B,
             0x2153..0x2154, 0x215B..0x215E, 0x2160..0x216B,
             0x2170..0x2179, 0x2190..0x2199, 0x21B8..0x21B9,
             0x21D2..0x21D2, 0x21D4..0x21D4, 0x21E7..0x21E7,
             0x2200..0x2200, 0x2202..0x2203, 0x2207..0x2208,
             0x220B..0x220B, 0x220F..0x220F, 0x2211..0x2211,
             0x2215..0x2215, 0x221A..0x221A, 0x221D..0x2220,
             0x2223..0x2223, 0x2225..0x2225, 0x2227..0x222C,
             0x222E..0x222E, 0x2234..0x2237, 0x223C..0x223D,
             0x2248..0x2248, 0x224C..0x224C, 0x2252..0x2252,
             0x2260..0x2261, 0x2264..0x2267, 0x226A..0x226B,
             0x226E..0x226F, 0x2282..0x2283, 0x2286..0x2287,
             0x2295..0x2295, 0x2299..0x2299, 0x22A5..0x22A5,
             0x22BF..0x22BF, 0x2312..0x2312, 0x2460..0x24E9,
             0x24EB..0x254B, 0x2550..0x2573, 0x2580..0x258F,
             0x2592..0x2595, 0x25A0..0x25A1, 0x25A3..0x25A9,
             0x25B2..0x25B3, 0x25B6..0x25B7, 0x25BC..0x25BD,
             0x25C0..0x25C1, 0x25C6..0x25C8, 0x25CB..0x25CB,
             0x25CE..0x25D1, 0x25E2..0x25E5, 0x25EF..0x25EF,
             0x2605..0x2606, 0x2609..0x2609, 0x260E..0x260F,
             0x2614..0x2615, 0x261C..0x261C, 0x261E..0x261E,
             0x2640..0x2640, 0x2642..0x2642, 0x2660..0x2661,
             0x2663..0x2665, 0x2667..0x266A, 0x266C..0x266D,
             0x266F..0x266F, 0x273D..0x273D, 0x2776..0x277F,
             0xE000..0xF8FF, 0xFE00..0xFE0F, 0xFFFD..0xFFFD,
             0xE0100..0xE01EF, 0xF0000..0xFFFFD, 0x100000..0x10FFFD,
            ]

          def wide_character?(character)
            binary_search_ranges(character, WIDE_CHARACTERS) or
              binary_search_ranges(character, AMBIGUOUS)
          end

          private
          def binary_search_ranges(character, ranges)
            if ranges.size.zero?
              false
            elsif ranges.size == 1
              ranges[0].include?(character)
            else
              half = ranges.size / 2
              range = ranges[half]
              if range.include?(character)
                true
              elsif character < range.begin
                binary_search_ranges(character, ranges[0...half])
              else
                binary_search_ranges(character, ranges[(half + 1)..-1])
              end
            end
          end
        end

        def initialize(line)
          @line = line
          @characters = @line.unpack("U*")
        end

        def [](*args)
          result = @characters[*args]
          if result.respond_to?(:pack)
            result.pack("U*")
          else
            result
          end
        end

        def each(&block)
          @characters.each(&block)
        end

        def size
          @characters.size
        end

        def to_s
          @line
        end

        def compute_width(start, _end)
          width = 0
          start.upto(_end - 1) do |i|
            if self.class.wide_character?(@characters[i])
              width += 2
            else
              width += 1
            end
          end
          width
        end
      end

      class ReadableDiffer < Differ
        def diff(options={})
          @result = []
          operations.each do |tag, from_start, from_end, to_start, to_end|
            case tag
            when :replace
              diff_lines(from_start, from_end, to_start, to_end)
            when :delete
              tag_deleted(@from[from_start...from_end])
            when :insert
              tag_inserted(@to[to_start...to_end])
            when :equal
              tag_equal(@from[from_start...from_end])
            else
              raise "unknown tag: #{tag}"
            end
          end
          @result
        end

        private
        def operations
          @operations ||= nil
          if @operations.nil?
            matcher = SequenceMatcher.new(@from, @to)
            @operations = matcher.operations
          end
          @operations
        end

        def default_ratio
          0.74
        end

        def cut_off_ratio
          0.75
        end

        def tag(mark, contents)
          contents.each do |content|
            @result << (mark + content)
          end
        end

        def tag_deleted(contents)
          tag("- ", contents)
        end

        def tag_inserted(contents)
          tag("+ ", contents)
        end

        def tag_equal(contents)
          tag("  ", contents)
        end

        def tag_difference(contents)
          tag("? ", contents)
        end

        def find_diff_line_info(from_start, from_end, to_start, to_end)
          best_ratio = default_ratio
          from_equal_index = to_equal_index = nil
          from_best_index = to_best_index = nil

          to_start.upto(to_end - 1) do |to_index|
            from_start.upto(from_end - 1) do |from_index|
              if @from[from_index] == @to[to_index]
                from_equal_index ||= from_index
                to_equal_index ||= to_index
                next
              end

              matcher = SequenceMatcher.new(@from[from_index], @to[to_index],
                                            &method(:space_character?))
              if matcher.ratio > best_ratio
                best_ratio = matcher.ratio
                from_best_index = from_index
                to_best_index = to_index
              end
            end
          end

          [best_ratio,
           from_equal_index, to_equal_index,
           from_best_index,  to_best_index]
        end

        def diff_lines(from_start, from_end, to_start, to_end)
          info = find_diff_line_info(from_start, from_end, to_start, to_end)
          best_ratio, from_equal_index, to_equal_index, *info = info
          from_best_index, to_best_index = info
          from_best_index ||= from_start
          to_best_index ||= to_start

          if best_ratio < cut_off_ratio
            if from_equal_index.nil?
              if to_end - to_start < from_end - from_start
                tag_inserted(@to[to_start...to_end])
                tag_deleted(@from[from_start...from_end])
              else
                tag_deleted(@from[from_start...from_end])
                tag_inserted(@to[to_start...to_end])
              end
              return
            end
            from_best_index = from_equal_index
            to_best_index = to_equal_index
            best_ratio = 1.0
          end

          _diff_lines(from_start, from_best_index, to_start, to_best_index)
          diff_line(@from[from_best_index], @to[to_best_index])
          _diff_lines(from_best_index + 1, from_end, to_best_index + 1, to_end)
        end

        def _diff_lines(from_start, from_end, to_start, to_end)
          if from_start < from_end
            if to_start < to_end
              diff_lines(from_start, from_end, to_start, to_end)
            else
              tag_deleted(@from[from_start...from_end])
            end
          else
            tag_inserted(@to[to_start...to_end])
          end
        end

        def line_operations(from_line, to_line)
          if !from_line.respond_to?(:force_encoding) and $KCODE == "UTF8"
            from_line = UTF8Line.new(from_line)
            to_line = UTF8Line.new(to_line)
          end
          matcher = SequenceMatcher.new(from_line, to_line,
                                        &method(:space_character?))
          [from_line, to_line, matcher.operations]
        end

        def compute_width(line, start, _end)
          if line.respond_to?(:encoding) and
              Encoding.compatible?(Encoding::UTF_8, line.encoding)
            utf8_line = line[start..._end].encode(Encoding::UTF_8)
            width = 0
            utf8_line.each_codepoint do |unicode_codepoint|
              if UTF8Line.wide_character?(unicode_codepoint)
                width += 2
              else
                width += 1
              end
            end
            width
          elsif line.is_a?(UTF8Line)
            line.compute_width(start, _end)
          else
            _end - start
          end
        end

        def diff_line(from_line, to_line)
          from_tags = ""
          to_tags = ""
          from_line, to_line, _operations = line_operations(from_line, to_line)
          _operations.each do |tag, from_start, from_end, to_start, to_end|
            from_width = compute_width(from_line, from_start, from_end)
            to_width = compute_width(to_line, to_start, to_end)
            case tag
            when :replace
              from_tags += "^" * from_width
              to_tags += "^" * to_width
            when :delete
              from_tags += "-" * from_width
            when :insert
              to_tags += "+" * to_width
            when :equal
              from_tags += " " * from_width
              to_tags += " " * to_width
            else
              raise "unknown tag: #{tag}"
            end
          end
          format_diff_point(from_line, to_line, from_tags, to_tags)
        end

        def format_diff_point(from_line, to_line, from_tags, to_tags)
          common = [n_leading_characters(from_line, ?\t),
                    n_leading_characters(to_line, ?\t)].min
          common = [common,
                    n_leading_characters(from_tags[0, common], " "[0])].min
          from_tags = from_tags[common..-1].rstrip
          to_tags = to_tags[common..-1].rstrip

          tag_deleted([from_line])
          unless from_tags.empty?
            tag_difference(["#{"\t" * common}#{from_tags}"])
          end
          tag_inserted([to_line])
          unless to_tags.empty?
            tag_difference(["#{"\t" * common}#{to_tags}"])
          end
        end

        def n_leading_characters(string, character)
          n = 0
          while string[n] == character
            n += 1
          end
          n
        end

        def space_character?(character)
          [" "[0], "\t"[0]].include?(character)
        end
      end

      class UnifiedDiffer < Differ
        def diff(options={})
          groups = SequenceMatcher.new(@from, @to).grouped_operations
          return [] if groups.empty?
          return [] if same_content?(groups)

          show_context = options[:show_context]
          show_context = true if show_context.nil?
          result = ["--- #{options[:from_label]}".rstrip,
                    "+++ #{options[:to_label]}".rstrip]
          groups.each do |operations|
            result << format_summary(operations, show_context)
            operations.each do |args|
              operation_tag, from_start, from_end, to_start, to_end = args
              case operation_tag
              when :replace
                result.concat(tag("-", @from[from_start...from_end]))
                result.concat(tag("+", @to[to_start...to_end]))
              when :delete
                result.concat(tag("-", @from[from_start...from_end]))
              when :insert
                result.concat(tag("+", @to[to_start...to_end]))
              when :equal
                result.concat(tag(" ", @from[from_start...from_end]))
              end
            end
          end
          result
        end

        private
        def same_content?(groups)
          return false if groups.size != 1
          group = groups[0]
          return false if group.size != 1
          tag, from_start, from_end, to_start, to_end = group[0]

          tag == :equal and [from_start, from_end] == [to_start, to_end]
        end

        def format_summary(operations, show_context)
          _, first_from_start, _, first_to_start, _ = operations[0]
          _, _, last_from_end, _, last_to_end = operations[-1]
          summary = "@@ -%d,%d +%d,%d @@" % [first_from_start + 1,
                                             last_from_end - first_from_start,
                                             first_to_start + 1,
                                             last_to_end - first_to_start,]
          if show_context
            interesting_line = find_interesting_line(first_from_start,
                                                     first_to_start,
                                                     :define_line?)
            summary << " #{interesting_line}" if interesting_line
          end
          summary
        end

        def find_interesting_line(from_start, to_start, predicate)
          from_index = from_start
          to_index = to_start
          while from_index >= 0 or to_index >= 0
            [@from[from_index], @to[to_index]].each do |line|
              return line if line and __send__(predicate, line)
            end

            from_index -= 1
            to_index -= 1
          end
          nil
        end

        def define_line?(line)
          /\A(?:[_a-zA-Z$]|\s*(?:class|module|def)\b)/ =~ line
        end
      end

      module_function
      def need_fold?(diff)
        /^[-+].{79}/ =~ diff
      end

      def fold(string)
        string.split(/\r?\n/).collect do |line|
          line.gsub(/(.{78})/, "\\1\n")
        end.join("\n")
      end

      def folded_readable(from, to, options={})
        readable(fold(from), fold(to), options)
      end

      def readable(from, to, options={})
        diff(ReadableDiffer, from, to, options)
      end

      def unified(from, to, options={})
        diff(UnifiedDiffer, from, to, options)
      end

      def diff(differ_class, from, to, options={})
        if from.respond_to?(:valid_encoding?) and not from.valid_encoding?
          from = from.dup.force_encoding("ASCII-8BIT")
        end
        if to.respond_to?(:valid_encoding?) and not to.valid_encoding?
          to = to.dup.force_encoding("ASCII-8BIT")
        end
        differ = differ_class.new(from.split(/\r?\n/), to.split(/\r?\n/))
        lines = differ.diff(options)
        if Object.const_defined?(:EncodingError)
          begin
            lines.join("\n")
          rescue EncodingError
            lines.collect {|line| line.force_encoding("ASCII-8BIT")}.join("\n")
          end
        else
          lines.join("\n")
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/error.rb000066400000000000000000000071571456346657200176740ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/util/backtracefilter'

module Test
  module Unit

    # Encapsulates an error in a test. Created by
    # Test::Unit::TestCase when it rescues an exception thrown
    # during the processing of a test.
    class Error
      include Util::BacktraceFilter

      attr_reader :test_name, :exception
      attr_reader :method_name

      SINGLE_CHARACTER = 'E'
      LABEL = "Error"

      # Creates a new Error with the given test_name and
      # exception.
      def initialize(test_name, exception, options={})
        @test_name = test_name
        @exception = exception
        @method_name = options[:method_name]
      end

      # Returns a single character representation of an error.
      def single_character_display
        SINGLE_CHARACTER
      end

      def label
        LABEL
      end

      # Returns the message associated with the error.
      def message
        "#{@exception.class.name}: #{@exception.message}"
      end

      # Returns a brief version of the error description.
      def short_display
        "#@test_name: #{message.split("\n")[0]}"
      end

      # Returns a verbose version of the error description.
      def long_display
        backtrace_display = location.join("\n    ")
        "#{label}:\n#@test_name:\n#{message}\n    #{backtrace_display}"
      end

      def location
        @location ||= filter_backtrace(@exception.backtrace)
      end
      alias_method :backtrace, :location # Deprecated

      # Overridden to return long_display.
      def to_s
        long_display
      end

      def critical?
        true
      end
    end

    module ErrorHandler
      class << self
        def included(base)
          base.exception_handler(:handle_all_exception)
        end
      end

      NOT_PASS_THROUGH_EXCEPTIONS = []
      NOT_PASS_THROUGH_EXCEPTION_NAMES = ["Timeout::Error"]
      PASS_THROUGH_EXCEPTIONS = [
        NoMemoryError,
        SignalException,
        Interrupt,
        SystemExit,
      ]
      PASS_THROUGH_EXCEPTION_NAMES = []
      private
      def handle_all_exception(exception)
        return false if pass_through_exception?(exception)

        problem_occurred
        add_error(exception)
        true
      end

      def pass_through_exception?(exception)
        case exception
        when *NOT_PASS_THROUGH_EXCEPTIONS
          return false
        end
        case exception.class.name
        when *NOT_PASS_THROUGH_EXCEPTION_NAMES
          return false
        end

        case exception
        when *PASS_THROUGH_EXCEPTIONS
          return true
        end
        case exception.class.name
        when *PASS_THROUGH_EXCEPTION_NAMES
          return true
        end

        false
      end

      def add_error(exception)
        error = Error.new(name, exception, :method_name => @method_name)
        current_result.add_error(error)
      end
    end

    module TestResultErrorSupport
      attr_reader :errors

      # Records a Test::Unit::Error.
      def add_error(error)
        @errors << error
        notify_fault(error)
        notify_changed
      end

      # Returns the number of errors this TestResult has
      # recorded.
      def error_count
        @errors.size
      end

      def error_occurred?
        not @errors.empty?
      end

      private
      def initialize_containers
        super
        @errors = []
        @summary_generators << :error_summary
        @problem_checkers << :error_occurred?
      end

      def error_summary
        "#{error_count} errors"
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/exception-handler.rb000066400000000000000000000053111456346657200221420ustar00rootroot00000000000000module Test
  module Unit
    module ExceptionHandler
      @@exception_handlers = []
      class << self
        def exception_handlers
          @@exception_handlers
        end

        def included(base)
          base.extend(ClassMethods)

          observer = Proc.new do |test_case, _, _, value, method_name|
            if value
              @@exception_handlers.unshift(method_name)
            else
              @@exception_handlers.delete(method_name)
            end
          end
          base.register_attribute_observer(:exception_handler, &observer)
        end
      end

      module ClassMethods
        def exception_handlers
          ExceptionHandler.exception_handlers
        end

        # @overload exception_handler(method_name)
        #   Add an exception handler method.
        #
        #   @param method_name [Symbol]
        #      The method name that handles exception raised in tests.
        #   @return [void]
        #
        # @overload exception_handler(&callback)
        #   Add an exception handler.
        #
        #   @yield [test, exception]
        #     Gives the test and the exception.
        #   @yieldparam test [Test::Unit::TestCase]
        #      The test where the exception is raised.
        #   @yieldparam exception [Exception]
        #      The exception that is raised in running the test.
        #   @yieldreturn [Boolean]
        #      Whether the handler handles the exception or not.
        #      The handler must return _true_ if the handler handles
        #      test exception, _false_ otherwise.
        #   @return [void]
        #
        # This is a public API for developers who extend test-unit.
        def exception_handler(*method_name_or_handlers, &block)
          if block_given?
            exception_handlers.unshift(block)
          else
            method_name_or_handlers.each do |method_name_or_handler|
              if method_name_or_handler.respond_to?(:call)
                handler = method_name_or_handler
                exception_handlers.unshift(handler)
              else
                method_name = method_name_or_handler
                attribute(:exception_handler, true, {}, method_name)
              end
            end
          end
        end

        def unregister_exception_handler(*method_name_or_handlers)
          method_name_or_handlers.each do |method_name_or_handler|
            if method_name_or_handler.respond_to?(:call)
              handler = method_name_or_handler
              exception_handlers.delete(handler)
            else
              method_name = method_name_or_handler
              attribute(:exception_handler, false, {}, method_name)
            end
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/failure.rb000066400000000000000000000121301456346657200201550ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

module Test
  module Unit

    # Encapsulates a test failure. Created by Test::Unit::TestCase
    # when an assertion fails.
    class Failure
      attr_reader :test_name, :location, :message
      attr_reader :method_name, :source_location
      attr_reader :expected, :actual, :user_message
      attr_reader :inspected_expected, :inspected_actual

      SINGLE_CHARACTER = 'F'
      LABEL = "Failure"

      # Creates a new Failure with the given location and
      # message.
      def initialize(test_name, location, message, options={})
        @test_name = test_name
        @location = location
        @message = message
        @method_name = options[:method_name]
        @source_location = options[:source_location]
        @expected = options[:expected]
        @actual = options[:actual]
        @inspected_expected = options[:inspected_expected]
        @inspected_actual = options[:inspected_actual]
        @user_message = options[:user_message]
      end
      
      # Returns a single character representation of a failure.
      def single_character_display
        SINGLE_CHARACTER
      end

      def label
        LABEL
      end

      # Returns a brief version of the error description.
      def short_display
        "#@test_name: #{@message.split("\n")[0]}"
      end

      # Returns a verbose version of the error description.
      def long_display
        if location.size == 1
          location_display = location[0].sub(/\A(.+:\d+).*/, ' [\\1]')
        else
          location_display = "\n    [#{location.join("\n     ")}]"
        end
        "#{label}:\n#@test_name#{location_display}:\n#@message"
      end

      # Overridden to return long_display.
      def to_s
        long_display
      end

      def critical?
        true
      end

      def diff
        @diff ||= compute_diff
      end

      private
      def compute_diff
        Assertions::AssertionMessage.delayed_diff(@expected, @actual).inspect
      end
    end

    module FailureHandler
      class << self
        def included(base)
          base.exception_handler(:handle_assertion_failed_error)
        end
      end

      # Report a failure.
      #
      # This is a public API for developers who extend test-unit.
      #
      # @param message [String] The description about the failure.
      # @param backtrace [Array] The backtrace for the failure.
      # @option options [Object] :expected
      #   The expected value of the assertion.
      # @option options [Object] :actual
      #   The actual value of the assertion.
      # @option options [String] :inspected_expected
      #   The inspected expected value of the assertion.
      #   It is used for diff between expected and actual of the failure.
      # @option options [String] :inspected_actual
      #   The inspected actual value of the assertion.
      #   It is used for diff between expected and actual of the failure.
      # @option options [String] :user_message
      #   The message of the assertion from user.
      # @option options [String] :method_name (@method_name)
      #   The method name of the test.
      # @option options [Array] :source_location
      #   The location where the test is defined. It is the same
      #   format as Proc#source_location. That is, it's an array of
      #   path and and line number where the test definition is
      #   started.
      # @return [void]
      def add_failure(message, backtrace, options={})
        default_options = {
          :method_name => @method_name,
          :source_location => self[:source_location],
        }
        failure = Failure.new(name, filter_backtrace(backtrace), message,
                              default_options.merge(options))
        current_result.add_failure(failure)
      end

      private
      def handle_assertion_failed_error(exception)
        return false unless exception.is_a?(AssertionFailedError)
        problem_occurred
        add_failure(exception.message, exception.backtrace,
                    :expected => exception.expected,
                    :actual => exception.actual,
                    :inspected_expected => exception.inspected_expected,
                    :inspected_actual => exception.inspected_actual,
                    :user_message => exception.user_message)
        true
      end
    end

    module TestResultFailureSupport
      attr_reader :failures

      # Records a Test::Unit::Failure.
      def add_failure(failure)
        @failures << failure
        notify_fault(failure)
        notify_changed
      end

      # Returns the number of failures this TestResult has
      # recorded.
      def failure_count
        @failures.size
      end

      def failure_occurred?
        not @failures.empty?
      end

      private
      def initialize_containers
        super
        @failures = []
        @summary_generators << :failure_summary
        @problem_checkers << :failure_occurred?
      end

      def failure_summary
        "#{failure_count} failures"
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/fault-location-detector.rb000066400000000000000000000053451456346657200232700ustar00rootroot00000000000000# Copyright (C) 2012  Kouhei Sutou 
#
# License: Ruby's

require "English"

module Test
  module Unit
    class FaultLocationDetector
      def initialize(fault, code_snippet_fetcher)
        @fault = fault
        @code_snippet_fetcher = code_snippet_fetcher
        extract_fault_information
      end

      def split_backtrace_entry(entry)
        match_data = /\A(.+):(\d+)(?::(.*))?\z/.match(entry)
        return nil if match_data.nil?
        file, line_number, context = match_data.to_a[1..-1]
        line_number = line_number.to_i
        if /\Ain [`'](.+?)'/ =~ context
          method_name = $1
          if /\Ablock (?:\(.+?\) )?in / =~ method_name
            method_name = $POSTMATCH
          end
        else
          method_name = nil
        end
        [file, line_number, context, method_name]
      end

      def target?(backtrace_entry)
        file, line_number, context, method_name =
          split_backtrace_entry(backtrace_entry)
        _ = context
        return false if file.nil?

        if @fault_source_location
          target_source_location?(file, line_number, method_name)
        elsif @fault_method_name
          target_method?(method_name)
        else
          true
        end
      end

      private
      def target_source_location?(file, line_number, method_name)
        fault_file, fault_line_number = @fault_source_location
        return false unless file.end_with?(fault_file)

        return false if line_number < fault_line_number

        lines = @code_snippet_fetcher.source(file)
        return false if lines.nil?

        base_indent_level = nil
        fault_line_number.step(lines.size) do |current_line_number|
          line = lines[current_line_number - 1]
          current_indent_level = guess_indent_level(line)
          base_indent_level ||= current_indent_level
          return true if current_line_number == line_number

          if current_line_number == fault_line_number
            break if /(?:\send|\})\s*$/ =~ line
          else
            break if current_indent_level == base_indent_level
          end
        end
        false
      end

      def target_method?(method_name)
        @fault_method_name == method_name
      end

      def guess_indent_level(line)
        if /\A(\s*)/ =~ line
          $1.sub(/\t/, " " * 8).count(" ")
        else
          0
        end
      end

      def extract_fault_information
        if @fault.respond_to?(:source_location)
          @fault_source_location = @fault.source_location
        else
          @fault_source_location = nil
        end

        if @fault.respond_to?(:method_name)
          @fault_method_name = @fault.method_name
        else
          @fault_method_name = nil
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/fixture.rb000066400000000000000000000225701456346657200202250ustar00rootroot00000000000000module Test
  module Unit
    module Fixture
      class << self
        def included(base)
          base.extend(ClassMethods)

          [:setup, :cleanup, :teardown].each do |type|
            observer = lambda do |test_case, _, _, value, callback|
              if value.nil?
                test_case.fixture[type].unregister(callback)
              else
                test_case.fixture[type].register(callback, value)
              end
            end
            base.register_attribute_observer(type, &observer)
          end
        end
      end

      class Fixture
        attr_reader :setup
        attr_reader :cleanup
        attr_reader :teardown
        def initialize(test_case)
          @test_case = test_case
          @setup = HookPoint.new(@test_case, :setup, :after => :append)
          @cleanup = HookPoint.new(@test_case, :cleanup, :before => :prepend)
          @teardown = HookPoint.new(@test_case, :teardown, :before => :prepend)
          @cached_before_callbacks = {}
          @cached_after_callbacks = {}
        end

        def [](type)
          case type
          when :setup
            @setup
          when :cleanup
            @cleanup
          when :teardown
            @teardown
          end
        end

        def before_callbacks(type)
          @cached_before_callbacks[type] ||= collect_before_callbacks(type)
        end

        def after_callbacks(type)
          @cached_after_callbacks[type] ||= collect_after_callbacks(type)
        end

        private
        def target_test_cases
          @cached_target_test_cases ||= collect_target_test_cases
        end

        def collect_before_callbacks(type)
          prepend_callbacks = []
          append_callbacks = []
          target_test_cases.each do |ancestor|
            prepend_callbacks << ancestor.fixture[type].before_prepend_callbacks
            append_callbacks << ancestor.fixture[type].before_append_callbacks
          end

          merge_callbacks(prepend_callbacks, append_callbacks)
        end

        def collect_after_callbacks(type)
          prepend_callbacks = []
          append_callbacks = []
          target_test_cases.each do |ancestor|
            prepend_callbacks << ancestor.fixture[type].after_prepend_callbacks
            append_callbacks << ancestor.fixture[type].after_append_callbacks
          end

          merge_callbacks(prepend_callbacks, append_callbacks)
        end

        def collect_target_test_cases
          ancestors = @test_case.ancestors
          base_index = ancestors.index(::Test::Unit::Fixture)
          interested_ancestors = ancestors[0, base_index].find_all do |ancestor|
            ancestor.is_a?(Class)
          end
          interested_ancestors.reverse
        end

        def merge_callbacks(prepend_callbacks, append_callbacks)
          all_callbacks = []
          prepend_callbacks.reverse_each do |callbacks|
            all_callbacks.concat(callbacks)
          end
          append_callbacks.each do |callbacks|
            all_callbacks.concat(callbacks)
          end
          all_callbacks
        end
      end

      class HookPoint
        def initialize(test_case, type, default_options)
          @test_case = test_case
          @type = type
          @default_options = default_options
          @callbacks = {}
          @before_prepend_callbacks = []
          @before_append_callbacks = []
          @after_prepend_callbacks = []
          @after_append_callbacks = []
          @unregistered_callbacks = []
        end

        def register(method_name_or_callback, options=nil)
          options ||= {}
          unless valid_register_options?(options)
            message = "must be {:before => :prepend}, " +
              "{:before => :append}, {:after => :prepend} or " +
              "{:after => :append}: #{options.inspect}"
            raise ArgumentError, message
          end

          if options.empty?
            options = @default_options
          end
          before_how = options[:before]
          after_how = options[:after]
          if method_name_or_callback.respond_to?(:call)
            callback = method_name_or_callback
            method_name = callback_method_name(callback)
            @test_case.attribute(:source_location,
                                 callback.source_location,
                                 method_name)
            # For Ruby 2.6 or earlier. callback may be GC-ed. If
            # callback is GC-ed, callback_method_name may be
            # duplicated because callback_method_name uses callback.object_id.
            # See also: https://github.com/test-unit/test-unit/issues/179
            @callbacks[callback] = true
            @test_case.__send__(:define_method, method_name, &callback)
          else
            method_name = method_name_or_callback
          end
          add_callback(method_name, before_how, after_how)
        end

        def unregister(method_name_or_callback)
          if method_name_or_callback.respond_to?(:call)
            callback = method_name_or_callback
            method_name = callback_method_name(callback)
          else
            method_name = method_name_or_callback
          end
          @unregistered_callbacks << method_name
        end

        def before_prepend_callbacks
          @before_prepend_callbacks - @unregistered_callbacks
        end

        def before_append_callbacks
          @before_append_callbacks - @unregistered_callbacks
        end

        def after_prepend_callbacks
          @after_prepend_callbacks - @unregistered_callbacks
        end

        def after_append_callbacks
          @after_append_callbacks - @unregistered_callbacks
        end

        private
        def valid_register_options?(options)
          return true if options.empty?
          return false if options.size > 1

          key = options.keys.first
          [:before, :after].include?(key) and
            [:prepend, :append].include?(options[key])
        end

        def callback_method_name(callback)
          "#{@type}_#{callback.object_id}"
        end

        def add_callback(method_name_or_callback, before_how, after_how)
          case before_how
          when :prepend
            @before_prepend_callbacks =
              [method_name_or_callback] | @before_prepend_callbacks
          when :append
            @before_append_callbacks |= [method_name_or_callback]
          else
            case after_how
            when :prepend
              @after_prepend_callbacks =
                [method_name_or_callback] | @after_prepend_callbacks
            when :append
              @after_append_callbacks |= [method_name_or_callback]
            end
          end
        end
      end

      module ClassMethods
        def fixture
          @fixture ||= Fixture.new(self)
        end

        def setup(*method_names, &callback)
          register_fixture(:setup, *method_names, &callback)
        end

        def unregister_setup(*method_names_or_callbacks)
          unregister_fixture(:setup, *method_names_or_callbacks)
        end

        def cleanup(*method_names, &callback)
          register_fixture(:cleanup, *method_names, &callback)
        end

        def unregister_cleanup(*method_names_or_callbacks)
          unregister_fixture(:cleanup, *method_names_or_callbacks)
        end

        def teardown(*method_names, &callback)
          register_fixture(:teardown, *method_names, &callback)
        end

        def unregister_teardown(*method_names_or_callbacks)
          unregister_fixture(:teardown, *method_names_or_callbacks)
        end

        private
        def register_fixture(fixture, *method_names, &callback)
          options = {}
          options = method_names.pop if method_names.last.is_a?(Hash)
          callbacks = method_names
          callbacks << callback if callback
          attribute(fixture, options, *callbacks)
        end

        def unregister_fixture(fixture, *method_names_or_callbacks)
          attribute(fixture, nil, *method_names_or_callbacks)
        end
      end

      private
      def run_fixture(type, options={}, &block)
        fixtures = [
          self.class.fixture.before_callbacks(type),
          type,
          self.class.fixture.after_callbacks(type),
        ].flatten
        if block
          runner = create_fixtures_runner(fixtures, options, &block)
          runner.call
        else
          fixtures.each do |method_name|
            run_fixture_callback(method_name, options)
          end
        end
      end

      def create_fixtures_runner(fixtures, options, &block)
        if fixtures.empty?
          block
        else
          last_fixture = fixtures.pop
          create_fixtures_runner(fixtures, options) do
            block_is_called = false
            run_fixture_callback(last_fixture, options) do
              block_is_called = true
              block.call
            end
            block.call unless block_is_called
          end
        end
      end

      def run_fixture_callback(method_name, options, &block)
        return unless respond_to?(method_name, true)
        begin
          __send__(method_name, &block)
        rescue Exception
          raise unless options[:handle_exception]
          raise unless handle_exception($!)
        end
      end

      def run_setup(&block)
        run_fixture(:setup, &block)
      end

      def run_cleanup
        run_fixture(:cleanup)
      end

      def run_teardown
        run_fixture(:teardown, :handle_exception => true)
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/notification.rb000066400000000000000000000065701456346657200212270ustar00rootroot00000000000000require 'test/unit/util/backtracefilter'

module Test
  module Unit
    class Notification
      include Util::BacktraceFilter
      attr_reader :test_name, :location, :message
      attr_reader :method_name

      SINGLE_CHARACTER = 'N'
      LABEL = "Notification"

      # Creates a new Notification with the given location and
      # message.
      def initialize(test_name, location, message, options={})
        @test_name = test_name
        @location = location
        @message = message
        @method_name = options[:method_name]
      end

      # Returns a single character representation of a notification.
      def single_character_display
        SINGLE_CHARACTER
      end

      def label
        LABEL
      end

      # Returns a brief version of the error description.
      def short_display
        "#{@test_name}: #{@message.split("\n")[0]}"
      end

      # Returns a verbose version of the error description.
      def long_display
        backtrace = filter_backtrace(location).join("\n")
        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
      end

      # Overridden to return long_display.
      def to_s
        long_display
      end

      def critical?
        false
      end
    end

    class NotifiedError < StandardError
    end


    module TestCaseNotificationSupport
      class << self
        def included(base)
          base.class_eval do
            include NotificationHandler
          end
        end
      end

      # Notify some information.
      #
      # Example:
      #
      #     def test_notification
      #       notify("I'm here!")
      #       # Reached here
      #       notify("Special!") if special_case?
      #       # Reached here too
      #     end
      #
      # options:
      #
      #     :backtrace override backtrace.
      def notify(message, options={}, &block)
        backtrace = filter_backtrace(options[:backtrace] || caller)
        notification = Notification.new(name, backtrace, message,
                                        :method_name => @method_name)
        add_notification(notification)
      end

      private
      def add_notification(notification)
        current_result.add_notification(notification)
      end
    end

    module NotificationHandler
      class << self
        def included(base)
          base.exception_handler(:handle_notified_error)
        end
      end

      private
      def handle_notified_error(exception)
        return false unless exception.is_a?(NotifiedError)
        notification = Notification.new(name,
                                        filter_backtrace(exception.backtrace),
                                        exception.message)
        add_notification(notification)
        true
      end
    end

    module TestResultNotificationSupport
      attr_reader :notifications

      # Records a Test::Unit::Notification.
      def add_notification(notification)
        @notifications << notification
        notify_fault(notification)
        notify_changed
      end

      # Returns the number of notifications this TestResult has
      # recorded.
      def notification_count
        @notifications.size
      end

      private
      def initialize_containers
        super
        @notifications = []
        @summary_generators << :notification_summary
      end

      def notification_summary
        "#{notification_count} notifications"
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/omission.rb000066400000000000000000000111441456346657200203720ustar00rootroot00000000000000require 'test/unit/util/backtracefilter'

module Test
  module Unit
    class Omission
      include Util::BacktraceFilter
      attr_reader :test_name, :location, :message
      attr_reader :method_name

      SINGLE_CHARACTER = 'O'
      LABEL = "Omission"

      # Creates a new Omission with the given location and
      # message.
      def initialize(test_name, location, message, options={})
        @test_name = test_name
        @location = location
        @message = message
        @method_name = options[:method_name]
      end

      # Returns a single character representation of a omission.
      def single_character_display
        SINGLE_CHARACTER
      end

      def label
        LABEL
      end

      # Returns a brief version of the error description.
      def short_display
        "#{@test_name}: #{@message.split("\n")[0]}"
      end

      # Returns a verbose version of the error description.
      def long_display
        backtrace = filter_backtrace(location).join("\n")
        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
      end

      # Overridden to return long_display.
      def to_s
        long_display
      end

      def critical?
        true
      end
    end

    class OmittedError < StandardError
    end


    module TestCaseOmissionSupport
      class << self
        def included(base)
          base.class_eval do
            include OmissionHandler
          end
        end
      end

      # Omit the test or part of the test.
      #
      # Example:
      #
      #     def test_omission
      #       omit
      #       # Not reached here
      #     end
      #
      #     def test_omission_with_here
      #       omit do
      #         # Not ran here
      #       end
      #       # Reached here
      #     end
      def omit(message=nil, &block)
        message ||= "omitted."
        if block_given?
          omission = Omission.new(name, filter_backtrace(caller), message,
                                  :method_name => @method_name)
          add_omission(omission)
        else
          raise OmittedError.new(message)
        end
      end

      # Omit the test or part of the test if _condition_ is
      # true.
      #
      # Example:
      #
      #     def test_omission
      #       omit_if("".empty?)
      #       # Not reached here
      #     end
      #
      #     def test_omission_with_here
      #       omit_if(true) do
      #         # Not ran here
      #       end
      #       omit_if(false) do
      #         # Reached here
      #       end
      #       # Reached here too
      #     end
      def omit_if(condition, *args, &block)
        if condition
          omit(*args, &block)
        else
          block.call if block
        end
      end

      # Omit the test or part of the test if _condition_ is
      # not true.
      #
      # Example:
      #
      #     def test_omission
      #       omit_unless("string".empty?)
      #       # Not reached here
      #     end
      #
      #     def test_omission_with_here
      #       omit_unless(true) do
      #         # Reached here
      #       end
      #       omit_unless(false) do
      #         # Not ran here
      #       end
      #       # Reached here too
      #     end
      def omit_unless(condition, *args, &block)
        if condition
          block.call if block
        else
          omit(*args, &block)
        end
      end

      private
      def add_omission(omission)
        current_result.add_omission(omission)
      end
    end

    module OmissionHandler
      class << self
        def included(base)
          base.exception_handler(:handle_omitted_error)
        end
      end

      private
      def handle_omitted_error(exception)
        return false unless exception.is_a?(OmittedError)
        omission = Omission.new(name,
                                filter_backtrace(exception.backtrace),
                                exception.message,
                                :method_name => @method_name)
        add_omission(omission)
        true
      end
    end

    module TestResultOmissionSupport
      attr_reader :omissions

      # Records a Test::Unit::Omission.
      def add_omission(omission)
        @omissions << omission
        notify_fault(omission)
        notify_changed
      end

      # Returns the number of omissions this TestResult has
      # recorded.
      def omission_count
        @omissions.size
      end

      private
      def initialize_containers
        super
        @omissions = []
        @summary_generators << :omission_summary
      end

      def omission_summary
        "#{omission_count} omissions"
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/pending.rb000066400000000000000000000072231456346657200201610ustar00rootroot00000000000000require 'test/unit/util/backtracefilter'

module Test
  module Unit
    class Pending
      include Util::BacktraceFilter
      attr_reader :test_name, :location, :message
      attr_reader :method_name

      SINGLE_CHARACTER = 'P'
      LABEL = "Pending"

      # Creates a new Pending with the given location and
      # message.
      def initialize(test_name, location, message, options={})
        @test_name = test_name
        @location = location
        @message = message
        @method_name = options[:method_name]
      end

      # Returns a single character representation of a pending.
      def single_character_display
        SINGLE_CHARACTER
      end

      def label
        LABEL
      end

      # Returns a brief version of the error description.
      def short_display
        "#{@test_name}: #{@message.split("\n")[0]}"
      end

      # Returns a verbose version of the error description.
      def long_display
        backtrace = filter_backtrace(location).join("\n")
        "#{label}: #{@message}\n#{@test_name}\n#{backtrace}"
      end

      # Overridden to return long_display.
      def to_s
        long_display
      end

      def critical?
        true
      end
    end

    class PendedError < StandardError
    end


    module TestCasePendingSupport
      class << self
        def included(base)
          base.class_eval do
            include PendingHandler
          end
        end
      end

      # Marks the test or part of the test is pending.
      #
      # Example:
      #
      #     def test_pending
      #       pend
      #       # Not reached here
      #     end
      #
      #     def test_pending_with_here
      #       pend do
      #         # Ran here
      #         # Fails if the block doesn't raise any error.
      #         # Because it means the block is passed unexpectedly.
      #       end
      #       # Reached here
      #     end
      def pend(message=nil, &block)
        message ||= "pended."
        if block_given?
          pending = nil
          begin
            yield
          rescue Exception
            pending = Pending.new(name, filter_backtrace(caller), message,
                                  :method_name => @method_name)
            add_pending(pending)
          end
          unless pending
            flunk("Pending block should not be passed: #{message}")
          end
        else
          raise PendedError.new(message)
        end
      end

      private
      def add_pending(pending)
        problem_occurred
        current_result.add_pending(pending)
      end
    end

    module PendingHandler
      class << self
        def included(base)
          base.exception_handler(:handle_pended_error)
        end
      end

      private
      def handle_pended_error(exception)
        return false unless exception.is_a?(PendedError)
        pending = Pending.new(name,
                              filter_backtrace(exception.backtrace),
                              exception.message,
                              :method_name => @method_name)
        add_pending(pending)
        true
      end
    end

    module TestResultPendingSupport
      attr_reader :pendings

      # Records a Test::Unit::Pending.
      def add_pending(pending)
        @pendings << pending
        notify_fault(pending)
        notify_changed
      end

      # Returns the number of pendings this TestResult has
      # recorded.
      def pending_count
        @pendings.size
      end

      private
      def initialize_containers
        super
        @pendings = []
        @summary_generators << :pending_summary
      end

      def pending_summary
        "#{pending_count} pendings"
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/priority.rb000066400000000000000000000106631456346657200204200ustar00rootroot00000000000000module Test
  module Unit
    module Priority
      class << self
        def included(base)
          base.extend(ClassMethods)

          base.class_eval do
            setup :priority_setup, :before => :prepend
            teardown :priority_teardown, :after => :append
          end
        end

        @@enabled = false
        def enabled?
          @@enabled
        end

        def enable
          require "fileutils"
          require "tmpdir"
          @@enabled = true
        end

        def disable
          @@enabled = false
        end

        @@default = :normal
        def default
          @@default || :normal
        end

        def default=(default)
          @@default = default
        end

        def available_values
          Checker.available_priorities
        end
      end

      class Checker
        class << self
          def have_priority?(name)
            singleton_class = (class << self; self; end)
            singleton_class.method_defined?(priority_check_method_name(name))
          end

          def need_to_run?(test)
            priority = test[:priority] || Priority.default
            if have_priority?(priority)
              __send__(priority_check_method_name(priority), test)
            else
              true
            end
          end

          def available_priorities
            methods(false).collect do |name|
              /\Arun_priority_(.+)\?\z/ =~ name.to_s
              $1
            end.compact
          end

          def run_priority_must?(test)
            true
          end

          def run_priority_important?(test)
            rand > 0.1
          end

          def run_priority_high?(test)
            rand > 0.3
          end

          def run_priority_normal?(test)
            rand > 0.5
          end

          def run_priority_low?(test)
            rand > 0.75
          end

          def run_priority_never?(test)
            false
          end

          private
          def priority_check_method_name(priority_name)
            "run_priority_#{priority_name}?"
          end
        end

        attr_reader :test
        def initialize(test)
          @test = test
        end

        def setup
          FileUtils.rm_f(passed_file)
        end

        def teardown
          if @test.__send__(:passed?)
            FileUtils.touch(passed_file)
          else
            FileUtils.rm_f(passed_file)
          end
        end

        def need_to_run?
          !previous_test_success? or self.class.need_to_run?(@test)
        end

        private
        def previous_test_success?
          File.exist?(passed_file)
        end

        def result_dir
          components = [
            ".test-result",
            escape_class_name(@test.class.name || "AnonymousTestCase"),
            escaped_method_name,
          ]
          parent_directories = [File.dirname($0), Dir.pwd]
          if Process.respond_to?(:uid)
            parent_directories << File.join(Dir.tmpdir, Process.uid.to_s)
          end
          parent_directories.each do |parent_directory|
            dir = File.expand_path(File.join(parent_directory, *components))
            begin
              FileUtils.mkdir_p(dir)
              return dir
            rescue Errno::EACCES
            end
          end

          raise Errno::EACCES, parent_directories.join(", ")
        end

        def passed_file
          File.join(result_dir, "passed")
        end

        def escape_class_name(class_name)
          escape_name(class_name)
        end

        def escaped_method_name
          escape_name(@test.method_name.to_s)
        end

        def escape_name(name)
          name.gsub(/(?:[: \/!?=])/) do |matched|
            case matched
            when ":"
              "_colon_"
            when " ", "/"
              "_"
            when "!"
              ".destructive"
            when "?"
              ".predicate"
            when "="
              ".equal"
            end
          end
        end
      end

      module ClassMethods
        def priority(name, *tests)
          unless Checker.have_priority?(name)
            raise ArgumentError, "unknown priority: #{name}"
          end
          attribute(:priority, name, {:keep => true}, *tests)
        end
      end

      def priority_setup
        return unless Priority.enabled?
        Checker.new(self).setup
      end

      def priority_teardown
        return unless Priority.enabled?
        Checker.new(self).teardown
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/runner/000077500000000000000000000000001456346657200175155ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/runner/console.rb000066400000000000000000000051051456346657200215050ustar00rootroot00000000000000# Copyright (C) 2008-2023  Sutou Kouhei 

module Test
  module Unit
    AutoRunner.register_runner(:console) do |auto_runner|
      require 'test/unit/ui/console/testrunner'
      Test::Unit::UI::Console::TestRunner
    end

    AutoRunner.setup_option do |auto_runner, opts|
      require 'test/unit/ui/console/outputlevel'

      output_levels = [
        ["silent", UI::Console::OutputLevel::SILENT],
        ["progress", UI::Console::OutputLevel::PROGRESS_ONLY],
        ["important-only", UI::Console::OutputLevel::IMPORTANT_FAULTS_ONLY],
        ["normal", UI::Console::OutputLevel::NORMAL],
        ["verbose", UI::Console::OutputLevel::VERBOSE],
      ]
      opts.on('-v', '--verbose=[LEVEL]', output_levels,
              "Set the output level (default is normal).",
              "(#{auto_runner.keyword_display(output_levels)})") do |level|
        level ||= output_levels.assoc("verbose")[1]
        auto_runner.runner_options[:output_level] = level
      end

      use_color_options = [
        [:auto, :auto],
        ["-", false],
        ["no", false],
        ["false", false],
        ["+", true],
        ["yes", true],
        ["true", true],
      ]
      opts.on("--[no-]use-color=[auto]", use_color_options,
              "Uses color output",
              "(default is auto)") do |use_color|
        case use_color
        when nil
          use_color = true
        when :auto
          use_color = nil
        end
        auto_runner.runner_options[:use_color] = use_color
      end

      opts.on("--progress-row-max=MAX", Integer,
              "Uses MAX as max terminal width for progress mark",
              "(default is auto)") do |max|
        auto_runner.runner_options[:progress_row_max] = max
      end

      progress_styles = [
        ["inplace", :inplace],
        ["mark", :mark],
        ["fault-only", :fault_only],
      ]
      opts.on("--progress-style=STYLE", progress_styles,
              "Uses STYLE as progress style",
              "(#{auto_runner.keyword_display(progress_styles)}") do |style|
        auto_runner.runner_options[:progress_style] = style
      end

      opts.on("--no-show-detail-immediately",
              "Shows not passed test details immediately.",
              "(default is yes)") do |boolean|
        auto_runner.runner_options[:show_detail_immediately] = boolean
      end

      opts.on("--[no-]reverse-output",
              "Shows fault details in reverse.",
              "(default is yes for tty output, no otherwise)") do |boolean|
        auto_runner.runner_options[:reverse_output] = boolean
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/runner/emacs.rb000066400000000000000000000002721456346657200211330ustar00rootroot00000000000000module Test
  module Unit
    AutoRunner.register_runner(:emacs) do |auto_runner|
      require 'test/unit/ui/emacs/testrunner'
      Test::Unit::UI::Emacs::TestRunner
    end
  end
end
test-unit-3.6.2/lib/test/unit/runner/xml.rb000066400000000000000000000006501456346657200206430ustar00rootroot00000000000000module Test
  module Unit
    AutoRunner.register_runner(:xml) do |auto_runner|
      require 'test/unit/ui/xml/testrunner'
      Test::Unit::UI::XML::TestRunner
    end

    AutoRunner.setup_option do |auto_runner, opts|
      opts.on("--output-file-descriptor=FD", Integer,
              "Outputs to file descriptor FD") do |fd|
        auto_runner.runner_options[:output_file_descriptor] = fd
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/test-suite-creator.rb000066400000000000000000000060751456346657200223040ustar00rootroot00000000000000#--
#
# Author:: Kouhei Sutou
# Copyright::
#   * Copyright (c) 2011 Kouhei Sutou 
# License:: Ruby license.

require "test/unit/data-sets"

module Test
  module Unit
    class TestSuiteCreator # :nodoc:
      class << self
        def test_method?(test_case, method_name)
          /\Atest./ =~ method_name.to_s or
            test_case.find_attribute(method_name, :test)
        end
      end

      def initialize(test_case)
        @test_case = test_case
      end

      def create
        suite = TestSuite.new(@test_case.name, @test_case)
        collect_test_names.each do |test_name|
          data_sets = extract_data_sets(test_name)
          if data_sets
            data_sets.each do |label, data|
              append_test(suite, test_name) do |test|
                test.assign_test_data(label, data)
              end
            end
          else
            append_test(suite, test_name)
          end
        end
        append_test(suite, "default_test") if suite.empty?
        suite
      end

      private
      def extract_data_sets(test_name)
        data_sets = @test_case.find_attribute(test_name,
                                              :data,
                                              :recursive => false)
        data_method_name = "data_#{test_name}"
        test = @test_case.new(test_name)
        if test.respond_to?(data_method_name)
          data_method = test.method(data_method_name)
          if data_method.arity <= 0
            data_sets ||= DataSets.new
            data_sets << data_method
          end
        end
        data_sets
      end

      def append_test(suite, test_name)
        test = @test_case.new(test_name)
        yield(test) if block_given?
        suite << test if test.valid?
      end

      def collect_test_names
        methods = @test_case.public_instance_methods(true)
        super_test_case = @test_case.superclass
        methods -= super_test_case.public_instance_methods(true)
        methods |= @test_case.public_instance_methods(false)
        method_names = methods.collect(&:to_s)
        test_names = method_names.find_all do |method_name|
          self.class.test_method?(@test_case, method_name)
        end
        __send__("sort_test_names_in_#{@test_case.test_order}_order", test_names)
      end

      def sort_test_names_in_alphabetic_order(test_names)
        test_names.sort
      end

      def sort_test_names_in_random_order(test_names)
        test_names.sort_by {rand(test_names.size)}
      end

      def sort_test_names_in_defined_order(test_names)
        added_method_names = @test_case.added_method_names
        test_names.sort do |test1, test2|
          test1_defined_order = added_method_names.index(test1)
          test2_defined_order = added_method_names.index(test2)
          if test1_defined_order and test2_defined_order
            test1_defined_order <=> test2_defined_order
          elsif test1_defined_order
            1
          elsif test2_defined_order
            -1
          else
            test1 <=> test2
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/testcase.rb000066400000000000000000000640561456346657200203570ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright::
#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
#   * Copyright (c) 2008-2012 Kouhei Sutou 
# License:: Ruby license.

require 'test/unit/attribute'
require 'test/unit/fixture'
require 'test/unit/exception-handler'
require 'test/unit/assertions'
require 'test/unit/failure'
require 'test/unit/error'
require 'test/unit/pending'
require 'test/unit/omission'
require 'test/unit/notification'
require 'test/unit/priority'
require 'test/unit/data'
require 'test/unit/testsuite'
require 'test/unit/test-suite-creator'
require 'test/unit/assertion-failed-error'
require 'test/unit/auto-runner-loader'
require 'test/unit/util/backtracefilter'
require 'test/unit/util/output'
require 'test/unit/util/method-owner-finder'

module Test
  module Unit

    # Ties everything together. If you subclass and add your own
    # test methods, it takes care of making them into tests and
    # wrapping those tests into a suite. It also does the
    # nitty-gritty of actually running an individual test and
    # collecting its results into a Test::Unit::TestResult object.
    #
    # You can run two hooks before/after a TestCase run.
    #
    # Example:
    #
    #     class TestMyClass < Test::Unit::TestCase
    #       class << self
    #         def startup
    #           ...
    #         end
    #
    #         def shutdown
    #           ...
    #         end
    #       end
    #
    #       def setup
    #         ...
    #       end
    #
    #       def cleanup
    #         ...
    #       end
    #
    #       def teardown
    #         ...
    #       end
    #
    #       def test_my_method1
    #         ...
    #       end
    #
    #       def test_my_method2
    #         ...
    #       end
    #     end
    #
    # Here is a call order:
    #
    # 1. startup
    # 1. setup
    # 1. test_my_method1
    # 1. cleanup
    # 1. teardown
    # 1. setup
    # 1. test_my_method2
    # 1. cleanup
    # 1. teardown
    # 1. shutdown
    #
    # You can set an attribute to each test.
    #
    # Example:
    #
    #     class TestMyClass < Test::Unit::TestCase
    #       attribute :speed, :fast
    #       def test_my_fast_method
    #         # You can get the attribute via `self[]`
    #         self[:speed] # => :fast
    #         ...
    #       end
    #
    #       attribute :speed, :slow
    #       def test_my_slow_method
    #         self[:speed] # => :slow
    #         ...
    #       end
    #     end
    class TestCase
      include Attribute
      include Fixture
      include ExceptionHandler
      include ErrorHandler
      include FailureHandler
      include TestCasePendingSupport
      include TestCaseOmissionSupport
      include TestCaseNotificationSupport
      include Priority
      include Data
      include Assertions
      include Util::BacktraceFilter
      include Util::Output

      STARTED = name + "::STARTED" # :nodoc:
      FINISHED = name + "::FINISHED" # :nodoc:
      STARTED_OBJECT = name + "::STARTED::OBJECT" # :nodoc:
      FINISHED_OBJECT = name + "::FINISHED::OBJECT" # :nodoc:

      DESCENDANTS = [] # :nodoc:
      AVAILABLE_ORDERS = [:alphabetic, :random, :defined] # :nodoc:

      class << self
        def inherited(sub_class) # :nodoc:
          DESCENDANTS << sub_class
          super
        end

        def include(*modules, &block) # :nodoc:
          result = super
          modules.each do |mod|
            mod.public_instance_methods(false).each do |method_name|
              AutoRunnerLoader.check(self, method_name.to_s)
            end
          end
          result
        end

        @@added_method_names = {}
        def method_added(name) # :nodoc:
          super
          added_method_names = (@@added_method_names[self] ||= {})
          stringified_name = name.to_s
          if added_method_names.key?(stringified_name)
            attribute(:redefined, {:backtrace => caller}, {}, stringified_name)
          end
          source_location = find_attribute(stringified_name, :source_location)
          if source_location
            path, line = source_location
          elsif respond_to?(:caller_locations, true)
            location = caller_locations(1, 1)[0]
            path = location.absolute_path || location.path
            line = location.lineno
          else
            # TODO: Remove me when Ruby 1.9 support is dropped
            path, line, = caller[0].split(/:(\d+)/, 2)
            line = line.to_i if line
          end
          location = {
            :method_name => stringified_name,
            :path => File.expand_path(path),
            :line => line,
          }
          add_method_location(location)
          added_method_names[stringified_name] = true
          AutoRunnerLoader.check(self, stringified_name)
        end

        def added_method_names # :nodoc:
          (@@added_method_names[self] ||= {}).keys
        end

        # Rolls up all of the test* methods in the fixture into
        # one suite, creating a new instance of the fixture for
        # each method.
        def suite
          suite_creator = TestSuiteCreator.new(self)
          suite_creator.create
        end

        # Called before every test case runs. Can be used
        # to set up fixture information used in test case
        # scope.
        #
        # Here is an example test case:
        #
        #     class TestMyClass < Test::Unit::TestCase
        #       class << self
        #         def startup
        #           ...
        #         end
        #       end
        #
        #       def setup
        #         ...
        #       end
        #
        #       def test_my_class1
        #         ...
        #       end
        #
        #       def test_my_class2
        #         ...
        #       end
        #     end
        #
        # Here is a call order:
        #
        # * startup
        # * setup
        # * test_my_class1 (or test_my_class2)
        # * setup
        # * test_my_class2 (or test_my_class1)
        #
        # Note that you should not assume test order. Tests
        # should be worked in any order.
        def startup
        end

        # Called after every test case runs. Can be used to tear
        # down fixture information used in test case scope.
        #
        # Here is an example test case:
        #
        #     class TestMyClass < Test::Unit::TestCase
        #       class << self
        #         def shutdown
        #           ...
        #         end
        #       end
        #
        #       def teardown
        #         ...
        #       end
        #
        #       def test_my_class1
        #         ...
        #       end
        #
        #       def test_my_class2
        #         ...
        #       end
        #     end
        #
        # Here is a call order:
        #
        # * test_my_class1 (or test_my_class2)
        # * teardown
        # * test_my_class2 (or test_my_class1)
        # * teardown
        # * shutdown
        #
        # Note that you should not assume test order. Tests
        # should be worked in any order.
        def shutdown
        end

        @@test_orders = {}

        # Returns the current test order. This returns
        # `:alphabetic` by default.
        def test_order
          ancestors.each do |ancestor|
            order = @@test_orders[ancestor]
            return order if order
          end
          AVAILABLE_ORDERS.first
        end

        # Sets the current test order.
        #
        # Here are the available _order_:
        #
        # :alphabetic
        # : Default. Tests are sorted in alphabetic order.
        #
        # :random
        # : Tests are sorted in random order.
        #
        # :defined
        # : Tests are sorted in defined order.
        def test_order=(order)
          @@test_orders[self] = order
        end

        # Defines a test in declarative syntax or marks
        # following method as a test method.
        #
        # In declarative syntax usage, the following two
        # test definitions are the almost same:
        #
        #     description "register user"
        #     def test_register_user
        #       ...
        #     end
        #
        #     test "register user" do
        #       ...
        #     end
        #
        # In test method mark usage, the "my_test_method" is
        # treated as a test method:
        #
        #     test
        #     def my_test_method
        #       assert_equal("call me", ...)
        #     end
        def test(*test_description_or_targets, &block)
          if block_given?
            test_description = test_description_or_targets.first
            if test_description.nil?
              raise ArgumentError, "test description is missing"
            end
            n_arguments = test_description_or_targets.size
            if n_arguments > 1
              message = "wrong number of arguments (#{n_arguments} for 1)"
              raise ArgumentError, message
            end
            method_name = "test: #{test_description}"
            description(test_description, method_name)
            attribute(:test, true, {}, method_name)
            if block.respond_to?(:source_location)
              attribute(:source_location, block.source_location, {}, method_name)
            end
            define_method(method_name, &block)
          else
            targets = test_description_or_targets
            attribute(:test, true, {}, *targets)
            targets.each do |target|
              AutoRunnerLoader.check(self, target)
            end
          end
        end

        # Describes a test.
        #
        # The following example associates "register a
        # normal user" description with "test_register"
        # test.
        #
        #     description "register a normal user"
        #     def test_register
        #       ...
        #     end
        def description(value, target=nil)
          targets = [target].compact
          attribute(:description, value, {}, *targets)
        end

        # Declares that the following test uses Ractor.
        #
        # Tests that use Ractor are executed at the end. Because multi
        # Ractor mode is enabled in the current process and it's not
        # disabled even when only one Ractor is running after running
        # a test that uses Ractor on Ruby 3.0. It will be solved in
        # the future.
        #
        # This is implemented by setting the `:ractor` attribute of
        # the test to `true`.
        #
        # @param options [Hash] See {Attribute::ClassMethods#attribute}
        #   for details.
        #
        # @return [void]
        #
        # @example Declares that test_do_something_with_ractor uses Ractor
        #
        #   ractor
        #   def test_do_something_with_ractor
        #     Ractor.new do
        #       # ...
        #     end
        #   end
        #
        # @since 3.4.6
        def ractor(options={})
          attribute(:ractor, true, options)
        end

        # Defines a sub test case.
        #
        # This is a syntax sugar. The both of the following codes are
        # the same in meaning:
        #
        # Standard:
        #
        #     class TestParent < Test::Unit::TestCase
        #       class TestChild < self
        #         def test_in_child
        #         end
        #       end
        #     end
        #
        # Syntax sugar:
        #
        #     class TestParent < Test::Unit::TestCase
        #       sub_test_case("TestChild") do
        #         def test_in_child
        #         end
        #       end
        #     end
        #
        # The difference of them are the following:
        #
        # * Test case created by {sub_test_case} is an anonymous class.
        #   So you can't refer the test case by name.
        # * The class name of class style must follow
        #   constant naming rule in Ruby. But the name of test case
        #   created by {sub_test_case} doesn't need to follow the rule.
        #   For example, you can use a space in name such as "child test".
        #
        # @param name [String] The name of newly created sub test case.
        # @yield
        #   The block is evaluated under the newly created sub test
        #   case class context.
        # @return [Test::Unit::TestCase] Created sub test case class.
        def sub_test_case(name, &block)
          sub_test_case = sub_test_case_class(name)
          sub_test_case.class_eval(&block)
          sub_test_case
        end

        # Checks whether a test that is matched the query is
        # defined.
        #
        # @option query [String] :path (nil)
        #   the path where a test is defined in.
        # @option query [Numeric] :line (nil)
        #   the line number where a test is defined at.
        # @option query [String] :method_name (nil)
        #   the method name for a test.
        def test_defined?(query)
          locations = find_locations(query)
          not locations.empty?
        end

        def find_locations(query)
          query_path = query[:path]
          query_line = query[:line]
          query_method_name = query[:method_name]

          available_locations = target_method_locations(query_path)
          if query_line
            available_locations = available_locations.sort_by do |location|
              -location[:line]
            end
            available_location = available_locations.find do |location|
              query_line >= location[:line]
            end
            return [] if available_location.nil?
            return [] if available_location[:test_case] != self
            available_locations = [available_location]
          end
          if query_method_name
            available_location = available_locations.find do |location|
              location[:test_case] == self and
                query_method_name == location[:method_name]
            end
            return [] if available_location.nil?
            available_locations = [available_location]
          end

          available_locations
        end

        private
        # @private
        @@method_locations = {}
        # @private
        @@method_location_mutex = Thread::Mutex.new

        # @private
        def method_locations
          @@method_locations[self] ||= []
        end

        # @private
        def add_method_location(location)
          @@method_location_mutex.synchronize do
            method_locations << location
          end
        end

        # @private
        def target_method_locations(path)
          @@method_location_mutex.synchronize do
            if path.nil?
              self_location = method_locations.first
              path = self_location[:path] if self_location
            end
            return [] if path.nil?

            target_locations = []
            @@method_locations.each do |test_case, locations|
              locations.each do |location|
                absolete_path = File.expand_path(path)
                location_path = location[:path]
                location_basename = File.basename(location_path)
                if location_path == absolete_path or location_basename == path
                  target_locations << location.merge(:test_case => test_case)
                end
              end
            end
            target_locations
          end
        end

        # @private
        def sub_test_case_class(name)
          parent_test_case = self
          Class.new(self) do
            singleton_class = class << self; self; end
            singleton_class.__send__(:define_method, :name) do
              [parent_test_case.name, name].compact.join("::")
            end
          end
        end
      end

      attr_reader :method_name

      # Creates a new instance of the fixture for running the
      # test represented by test_method_name.
      def initialize(test_method_name)
        @method_name = test_method_name
        @internal_data = InternalData.new
      end

      # Assigns test data to the test. It is used in internal.
      def assign_test_data(label, data) # :nodoc:
        @internal_data.assign_test_data(label, data)
      end

      # Returns the test is valid test. It is used in internal.
      def valid? # :nodoc:
        return false unless respond_to?(@method_name)
        test_method = method(@method_name)
        unless @internal_data.have_test_data?
          return false unless test_method.arity <= 0
        end
        owner = Util::MethodOwnerFinder.find(self, @method_name)
        if owner.class != Module and self.class != owner
          return false
        end
        true
      end

      # Runs the individual test method represented by this
      # instance of the fixture, collecting statistics, failures
      # and errors in result.
      def run(result)
        begin
          @_result = result
          @internal_data.test_started
          yield(STARTED, name)
          yield(STARTED_OBJECT, self)
          processed_exception_in_setup = false
          begin
            catch do |tag|
              run_setup do
                begin
                  run_test
                  run_cleanup
                  add_pass
                rescue Exception
                  @internal_data.interrupted
                  unless handle_exception($!)
                    processed_exception_in_setup = true
                    raise
                  end
                  throw(tag)
                end
              end
            end
          rescue Exception
            if processed_exception_in_setup
              raise
            else
              @internal_data.interrupted
              raise unless handle_exception($!)
            end
          ensure
            begin
              run_teardown
            rescue Exception
              raise unless handle_exception($!)
            end
          end
          @internal_data.test_finished
          result.add_run
          yield(FINISHED, name)
          yield(FINISHED_OBJECT, self)
        ensure
          # @_result = nil # For test-spec's after_all :<
        end
      end

      # Called before every test method runs. Can be used
      # to set up fixture information.
      #
      # You can add additional setup tasks by the following
      # code:
      #
      #     class TestMyClass < Test::Unit::TestCase
      #       def setup
      #         ...
      #       end
      #
      #       setup
      #       def my_setup1
      #         ...
      #       end
      #
      #       setup do
      #         ... # setup callback1
      #       end
      #
      #       setup
      #       def my_setup2
      #         ...
      #       end
      #
      #       setup do
      #         ... # setup callback2
      #       end
      #
      #       def test_my_class
      #         ...
      #       end
      #     end
      #
      # Here is a call order:
      #
      # * setup
      # * my_setup1
      # * setup callback1
      # * my_setup2
      # * setup callback2
      # * test_my_class
      def setup
      end

      # Called after every test method runs but the test
      # method isn't marked as 'passed'. Can be used to
      # clean up and/or verify tested condition.
      # e.g. Can be used to verify mock.
      #
      # You can add additional cleanup tasks by the following
      # code:
      #
      #     class TestMyClass < Test::Unit::TestCase
      #       def cleanup
      #         ...
      #       end
      #
      #       cleanup
      #       def my_cleanup1
      #         ...
      #       end
      #
      #       cleanup do
      #         ... # cleanup callback1
      #       end
      #
      #       cleanup
      #       def my_cleanup2
      #         ...
      #       end
      #
      #       cleanup do
      #         ... # cleanup callback2
      #       end
      #
      #       def test_my_class
      #         ...
      #       end
      #     end
      #
      # Here is a call order:
      #
      # * test_my_class
      # * cleanup callback2
      # * my_cleanup2
      # * cleanup callback1
      # * my_cleanup1
      # * cleanup
      def cleanup
      end

      # Called after every test method runs. Can be used to tear
      # down fixture information.
      #
      # You can add additional teardown tasks by the following
      # code:
      #
      #     class TestMyClass < Test::Unit::TestCase
      #       def teardown
      #         ...
      #       end
      #
      #       teardown
      #       def my_teardown1
      #         ...
      #       end
      #
      #       teardown do
      #         ... # teardown callback1
      #       end
      #
      #       teardown
      #       def my_teardown2
      #         ...
      #       end
      #
      #       teardown do
      #         ... # teardown callback2
      #       end
      #
      #       def test_my_class
      #         ...
      #       end
      #     end
      #
      # Here is a call order:
      #
      # * test_my_class
      # * teardown callback2
      # * my_teardown2
      # * teardown callback1
      # * my_teardown1
      # * teardown
      def teardown
      end

      def default_test
        flunk("No tests were specified")
      end

      def size
        1
      end

      # Returns a label of test data for the test. If the
      # test isn't associated with any test data, it returns
      # `nil`.
      def data_label
        @internal_data.test_data_label
      end

      # Returns test data for the test. If the test isn't associated
      # with any test data, it returns `nil`.
      def data
        @internal_data.test_data
      end

      # Returns a human-readable name for the specific test that
      # this instance of TestCase represents.
      def name
        "#{local_name}(#{self.class.name})"
      end

      # Returns a human-readable name for the specific test that this
      # instance of TestCase represents.
      #
      # `#local_name` doesn't include class name. `#name` includes
      # class name.
      def local_name
        if @internal_data.have_test_data?
          "#{@method_name}[#{data_label}]"
        else
          @method_name.to_s
        end
      end

      # Returns a description for the test. A description
      # will be associated by Test::Unit::TestCase.test or
      # Test::Unit::TestCase.description.
      #
      # Returns a name for the test for no description test.
      def description
        self[:description] || name
      end

      # Overridden to return #name.
      def to_s
        name
      end

      # It's handy to be able to compare TestCase instances.
      def ==(other)
        return false unless other.kind_of?(self.class)
        return false unless @method_name == other.method_name
        return false unless data_label == other.data_label
        self.class == other.class
      end

      # Returns a Time at the test was started.
      def start_time
        @internal_data.start_time
      end

      # Returns elapsed time for the test was ran.
      def elapsed_time
        @internal_data.elapsed_time
      end

      # Returns whether the test is interrupted.
      def interrupted?
        @internal_data.interrupted?
      end

      # Returns whether this individual test passed or
      # not. Primarily for use in teardown so that artifacts
      # can be left behind if the test fails.
      def passed?
        @internal_data.passed?
      end

      # Notify that a problem is occurred in the test. It means that
      # the test is a failed test. If any failed tests exist in test
      # suites, the test process exits with failure exit status.
      #
      # This is a public API for developers who extend test-unit.
      #
      # @return [void]
      def problem_occurred
        @internal_data.problem_occurred
      end

      # Notify that the test is passed. Normally, it is not needed
      # because #run calls it automatically. If you want to override
      # #run, it is not a good idea. Please contact test-unit
      # developers. We will help you without your custom #run. For
      # example, we may add a new hook in #run.
      #
      # This is a public API for developers who extend test-unit.
      #
      # @return [void]
      def add_pass
        current_result.add_pass
      end

      private
      def current_result
        @_result
      end

      def run_test
        signature = "#{self.class}\##{@method_name}"
        redefined_info = self[:redefined]
        if redefined_info
          notify("<#{signature}> was redefined",
                 :backtrace => redefined_info[:backtrace])
        end
        if self[:ractor] and not defined?(::Ractor)
          omit("<#{signature}> requires Ractor")
        end
        if @internal_data.have_test_data?
          test_method = method(@method_name)
          arity = test_method.arity
          if arity.zero?
            __send__(@method_name)
          else
            __send__(@method_name, @internal_data.test_data)
          end
        else
          __send__(@method_name)
        end
      end

      def handle_exception(exception)
        self.class.exception_handlers.each do |handler|
          if handler.respond_to?(:call)
            handled = handler.call(self, exception)
          else
            handled = __send__(handler, exception)
          end
          return true if handled
        end
        false
      end

      def add_assertion
        current_result.add_assertion
      end

      class InternalData
        attr_reader :start_time, :elapsed_time
        attr_reader :test_data_label, :test_data
        def initialize
          @start_time = nil
          @elapsed_time = nil
          @passed = true
          @interrupted = false
          @test_data_label = nil
          @test_data = nil
        end

        def passed?
          @passed
        end

        def interrupted?
          @interrupted
        end

        def assign_test_data(label, data)
          @test_data_label = label
          @test_data = data
        end

        def have_test_data?
          not @test_data_label.nil?
        end

        def test_started
          @start_time = Time.now
        end

        def test_finished
          @elapsed_time = Time.now - @start_time
        end

        def problem_occurred
          @passed = false
        end

        def interrupted
          @interrupted = true
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/testresult.rb000066400000000000000000000063121456346657200207510ustar00rootroot00000000000000#--
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/util/observable'
require 'test/unit/failure'
require 'test/unit/error'
require 'test/unit/omission'
require 'test/unit/pending'
require 'test/unit/notification'

module Test
  module Unit
    module NullResultContainerInitializer
      private
      def initialize_containers
      end
    end

    # Collects Test::Unit::Failure and Test::Unit::Error so that
    # they can be displayed to the user. To this end, observers
    # can be added to it, allowing the dynamic updating of, say, a
    # UI.
    class TestResult
      include Util::Observable
      include NullResultContainerInitializer
      include TestResultFailureSupport
      include TestResultErrorSupport
      include TestResultPendingSupport
      include TestResultOmissionSupport
      include TestResultNotificationSupport

      FINISHED = name + "::FINISHED"
      CHANGED = name + "::CHANGED"
      PASS_ASSERTION = name + "::PASS_ASSERTION"
      FAULT = name + "::FAULT"

      attr_reader :run_count, :pass_count, :assertion_count, :faults

      attr_accessor :stop_tag

      # Constructs a new, empty TestResult.
      def initialize
        @run_count, @pass_count, @assertion_count = 0, 0, 0
        @summary_generators = []
        @problem_checkers = []
        @faults = []
        @stop_tag = nil
        initialize_containers
      end

      # Records a test run.
      def add_run
        @run_count += 1
        notify_listeners(FINISHED, self)
        notify_changed
      end

      def add_pass
        @pass_count += 1
      end

      # Records an individual assertion.
      def add_assertion
        @assertion_count += 1
        notify_listeners(PASS_ASSERTION, self)
        notify_changed
      end

      # Returns a string contain the recorded runs, assertions,
      # failures and errors in this TestResult.
      def summary
        ["#{run_count} tests",
         "#{assertion_count} assertions",
         *@summary_generators.collect {|generator| __send__(generator)}].join(", ")
      end

      # Returnes a string that shows result status.
      def status
        if passed?
          if pending_count > 0
            "pending"
          elsif omission_count > 0
            "omission"
          elsif notification_count > 0
            "notification"
          else
            "pass"
          end
        elsif error_count > 0
          "error"
        elsif failure_count > 0
          "failure"
        end
      end

      def stop
        throw @stop_tag
      end

      def to_s
        summary
      end

      # Returns whether or not this TestResult represents
      # successful completion.
      def passed?
        @problem_checkers.all? {|checker| not __send__(checker)}
      end

      def pass_percentage
        n_tests = @run_count - omission_count
        if n_tests.zero?
          0
        else
          100.0 * (@pass_count / n_tests.to_f)
        end
      end

      private
      def notify_changed
        notify_listeners(CHANGED, self)
      end

      def notify_fault(fault)
        @faults << fault
        notify_listeners(FAULT, fault)
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/testsuite.rb000066400000000000000000000114651456346657200205710ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# Copyright:: Copyright (c) 2008-2011 Kouhei Sutou. All rights reserved.
# License:: Ruby license.

require 'test/unit/error'

module Test
  module Unit

    # A collection of tests which can be #run.
    #
    # Note: It is easy to confuse a TestSuite instance with
    # something that has a static suite method; I know because _I_
    # have trouble keeping them straight. Think of something that
    # has a suite method as simply providing a way to get a
    # meaningful TestSuite instance.
    class TestSuite
      attr_reader :name, :tests, :test_case, :start_time, :elapsed_time

      # Test suite that has higher priority is ran prior to
      # test suites that have lower priority.
      attr_accessor :priority

      STARTED = name + "::STARTED"
      STARTED_OBJECT = name + "::STARTED::OBJECT"
      FINISHED = name + "::FINISHED"
      FINISHED_OBJECT = name + "::FINISHED::OBJECT"

      # Creates a new TestSuite with the given name.
      def initialize(name="Unnamed TestSuite", test_case=nil)
        @name = name
        @tests = []
        @test_case = test_case
        @n_tests = 0
        @priority = 0
        @start_time = nil
        @elapsed_time = nil
        @passed = true
      end

      # Runs the tests and/or suites contained in this
      # TestSuite.
      def run(result, &progress_block)
        @start_time = Time.now
        yield(STARTED, name)
        yield(STARTED_OBJECT, self)
        run_startup(result)
        while test = @tests.shift
          @n_tests += test.size
          run_test(test, result, &progress_block)
          @passed = false unless test.passed?
        end
      ensure
        begin
          run_shutdown(result)
        ensure
          @elapsed_time = Time.now - @start_time
          yield(FINISHED, name)
          yield(FINISHED_OBJECT, self)
        end
      end

      # Adds the test to the suite.
      def <<(test)
        @tests << test
        self
      end

      def delete(test)
        @tests.delete(test)
      end

      def delete_tests(tests)
        @tests -= tests
      end

      # Returns the rolled up number of tests in this suite;
      # i.e. if the suite contains other suites, it counts the
      # tests within those suites, not the suites themselves.
      def size
        total_size = @n_tests
        @tests.each { |test| total_size += test.size }
        total_size
      end

      def empty?
        size.zero?
      end

      # Overridden to return the name given the suite at
      # creation.
      def to_s
        @name
      end

      # It's handy to be able to compare TestSuite instances.
      def ==(other)
        return false unless(other.kind_of?(self.class))
        return false unless(@name == other.name)
        @tests == other.tests
      end

      def passed?
        @passed
      end

      private
      def run_startup(result)
        return if @test_case.nil? or !@test_case.respond_to?(:startup)
        begin
          @test_case.startup
        rescue Exception
          raise unless handle_exception($!, result)
        end
      end

      def run_test(test, result)
        finished_is_yielded = false
        finished_object_is_yielded = false
        previous_event_name = nil
        test.run(result) do |event_name, *args|
          case previous_event_name
          when Test::Unit::TestCase::STARTED
            if event_name != Test::Unit::TestCase::STARTED_OBJECT
              yield(Test::Unit::TestCase::STARTED_OBJECT, test)
            end
          when Test::Unit::TestCase::FINISHED
            if event_name != Test::Unit::TestCase::FINISHED_OBJECT
              yield(Test::Unit::TestCase::FINISHED_OBJECT, test)
            end
            finished_object_is_yielded = true
          end

          case event_name
          when Test::Unit::TestCase::STARTED
            finished_is_yielded = false
            finished_object_is_yielded = false
          when Test::Unit::TestCase::FINISHED
            finished_is_yielded = true
          end

          previous_event_name = event_name
          yield(event_name, *args)
        end

        if finished_is_yielded and not finished_object_is_yielded
          yield(Test::Unit::TestCase::FINISHED_OBJECT, test)
        end
      end

      def run_shutdown(result)
        return if @test_case.nil? or !@test_case.respond_to?(:shutdown)
        begin
          @test_case.shutdown
        rescue Exception
          raise unless handle_exception($!, result)
        end
      end

      def handle_exception(exception, result)
        case exception
        when *ErrorHandler::PASS_THROUGH_EXCEPTIONS
          false
        else
          result.add_error(Error.new(@test_case.name, exception))
          @passed = false
          true
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/000077500000000000000000000000001456346657200166215ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/ui/console/000077500000000000000000000000001456346657200202635ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/ui/console/outputlevel.rb000066400000000000000000000004001456346657200231720ustar00rootroot00000000000000module Test
  module Unit
    module UI
      module Console
        module OutputLevel
          SILENT = 0
          PROGRESS_ONLY = 1
          IMPORTANT_FAULTS_ONLY = 2
          NORMAL = 3
          VERBOSE = 4
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/console/testrunner.rb000066400000000000000000000635231456346657200230320ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright::
#   * Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
#   * Copyright (c) 2008-2023 Sutou Kouhei 
# License:: Ruby license.

begin
  require 'io/console'
rescue LoadError
end

require 'test/unit/color-scheme'
require 'test/unit/code-snippet-fetcher'
require 'test/unit/fault-location-detector'
require 'test/unit/diff'
require 'test/unit/ui/testrunner'
require 'test/unit/ui/testrunnermediator'
require 'test/unit/ui/console/outputlevel'

module Test
  module Unit
    module UI
      module Console

        # Runs a Test::Unit::TestSuite on the console.
        class TestRunner < UI::TestRunner
          include OutputLevel

          # Creates a new TestRunner for running the passed
          # suite. If quiet_mode is true, the output while
          # running is limited to progress dots, errors and
          # failures, and the final result. io specifies
          # where runner output should go to; defaults to
          # STDOUT.
          def initialize(suite, options={})
            super
            @output_level = @options[:output_level] || guess_output_level
            @output = @options[:output] || STDOUT
            @use_color = @options[:use_color]
            @use_color = guess_color_availability if @use_color.nil?
            @color_scheme = @options[:color_scheme] || ColorScheme.default
            @reset_color = Color.new("reset")
            @progress_style = @options[:progress_style] || guess_progress_style
            @progress_marks = ["|", "/", "-", "\\", "|", "/", "-", "\\"]
            @progress_mark_index = 0
            @progress_row = 0
            @progress_row_max = @options[:progress_row_max]
            @progress_row_max ||= guess_progress_row_max
            @show_detail_immediately = @options[:show_detail_immediately]
            @show_detail_immediately = true if @show_detail_immediately.nil?
            @already_outputted = false
            @indent = 0
            @top_level = true
            @current_output_level = NORMAL
            @faults = []
            @code_snippet_fetcher = CodeSnippetFetcher.new
            @test_suites = []
          end

          private
          def change_output_level(level)
            old_output_level = @current_output_level
            @current_output_level = level
            yield
            @current_output_level = old_output_level
          end

          def setup_mediator
            super
            output_setup_end
          end

          def output_setup_end
            suite_name = @suite.to_s
            suite_name = @suite.name if @suite.kind_of?(Module)
            output("Loaded suite #{suite_name}")
          end

          def attach_to_mediator
            @mediator.add_listener(TestResult::FAULT,
                                   &method(:add_fault))
            @mediator.add_listener(TestRunnerMediator::STARTED,
                                   &method(:started))
            @mediator.add_listener(TestRunnerMediator::FINISHED,
                                   &method(:finished))
            @mediator.add_listener(TestCase::STARTED_OBJECT,
                                   &method(:test_started))
            @mediator.add_listener(TestCase::FINISHED_OBJECT,
                                   &method(:test_finished))
            @mediator.add_listener(TestSuite::STARTED_OBJECT,
                                   &method(:test_suite_started))
            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
                                   &method(:test_suite_finished))
          end

          def add_fault(fault)
            @faults << fault
            output_progress(fault.single_character_display,
                            fault_marker_color(fault))
            output_progress_in_detail(fault) if @show_detail_immediately
            @already_outputted = true if fault.critical?
          end

          def started(result)
            @result = result
            output_started
          end

          def output_started
            output("Started")
          end

          def finished(elapsed_time)
            unless @show_detail_immediately
              nl if output?(NORMAL) and !output?(VERBOSE)
              output_faults
            end
            case @progress_style
            when :inplace
              output_single("\r", nil, PROGRESS_ONLY)
            when :mark
              nl(PROGRESS_ONLY)
            end
            output_statistics(elapsed_time)
          end

          def output_faults
            categorized_faults = categorize_faults
            change_output_level(IMPORTANT_FAULTS_ONLY) do
              output_faults_in_detail(categorized_faults[:need_detail_faults])
            end
            output_faults_in_short("Omissions", Omission,
                                   categorized_faults[:omissions])
            output_faults_in_short("Notifications", Notification,
                                   categorized_faults[:notifications])
          end

          def max_digit(max_number)
            (Math.log10(max_number) + 1).truncate
          end

          def output_faults_in_detail(faults)
            return if faults.nil?
            digit = max_digit(faults.size)
            faults.each_with_index do |fault, index|
              nl
              output_single("%#{digit}d) " % (index + 1))
              output_fault_in_detail(fault)
            end
          end

          def output_faults_in_short(label, fault_class, faults)
            return if faults.nil?
            digit = max_digit(faults.size)
            nl
            output_single(label, fault_class_color(fault_class))
            output(":")
            faults.each_with_index do |fault, index|
              output_single("%#{digit}d) " % (index + 1))
              output_fault_in_short(fault)
            end
          end

          def categorize_faults
            faults = {}
            @faults.each do |fault|
              category = categorize_fault(fault)
              faults[category] ||= []
              faults[category] << fault
            end
            faults
          end

          def categorize_fault(fault)
            case fault
            when Omission
              :omissions
            when Notification
              :notifications
            else
              :need_detail_faults
            end
          end

          def output_fault_in_detail(fault)
            if fault.is_a?(Failure) and
                fault.inspected_expected and
                fault.inspected_actual
              output_single("#{fault.label}: ")
              output(fault.test_name, fault_color(fault))
              output_fault_backtrace(fault)
              output_failure_message(fault)
            else
              output_single("#{fault.label}: ")
              output_single(fault.test_name, fault_color(fault))
              output_fault_message(fault)
              output_fault_backtrace(fault)
            end
          end

          def output_fault_message(fault)
            message = fault.message
            return if message.nil?

            if message.include?("\n")
              output(":")
              message.each_line do |line|
                output("  #{line.chomp}")
              end
            else
              output(": #{message}")
            end
          end

          def output_fault_backtrace(fault)
            detector = FaultLocationDetector.new(fault, @code_snippet_fetcher)
            backtrace = fault.location
            # workaround for test-spec. :<
            # see also GitHub:#22
            backtrace ||= []

            code_snippet_backtrace_index = nil
            code_snippet_lines = nil
            backtrace.each_with_index do |entry, i|
              next unless detector.target?(entry)
              file, line_number, = detector.split_backtrace_entry(entry)
              lines = fetch_code_snippet(file, line_number)
              unless lines.empty?
                code_snippet_backtrace_index = i
                code_snippet_lines = lines
                break
              end
            end

            backtrace.each_with_index do |entry, i|
              output(entry)
              if i == code_snippet_backtrace_index
                output_code_snippet(code_snippet_lines, fault_color(fault))
              end
            end
          end

          def fetch_code_snippet(file, line_number)
            @code_snippet_fetcher.fetch(file, line_number)
          end

          def output_code_snippet(lines, target_line_color=nil)
            max_n = lines.collect {|n, line, attributes| n}.max
            digits = (Math.log10(max_n) + 1).truncate
            lines.each do |n, line, attributes|
              if attributes[:target_line?]
                line_color = target_line_color
                current_line_mark = "=>"
              else
                line_color = nil
                current_line_mark = ""
              end
              output("  %2s %*d: %s" % [current_line_mark, digits, n, line],
                     line_color)
            end
          end

          def output_failure_message(failure)
            if failure.expected.respond_to?(:encoding) and
                failure.actual.respond_to?(:encoding) and
                failure.expected.encoding != failure.actual.encoding
              need_encoding = true
            else
              need_encoding = false
            end
            output(failure.user_message) if failure.user_message
            output_single("<")
            output_single(failure.inspected_expected, color("pass"))
            output_single(">")
            if need_encoding
              output_single("(")
              output_single(failure.expected.encoding.name, color("pass"))
              output_single(")")
            end
            output(" expected but was")
            output_single("<")
            output_single(failure.inspected_actual, color("failure"))
            output_single(">")
            if need_encoding
              output_single("(")
              output_single(failure.actual.encoding.name, color("failure"))
              output_single(")")
            end
            output("")
            from, to = prepare_for_diff(failure.expected, failure.actual)
            if from and to
              if need_encoding
                unless from.valid_encoding?
                  from = from.dup.force_encoding("ASCII-8BIT")
                end
                unless to.valid_encoding?
                  to = to.dup.force_encoding("ASCII-8BIT")
                end
              end
              from_lines = from.split(/\r?\n/)
              to_lines = to.split(/\r?\n/)
              if need_encoding
                from_lines << ""
                to_lines << ""
                from_lines << "Encoding: #{failure.expected.encoding.name}"
                to_lines << "Encoding: #{failure.actual.encoding.name}"
              end
              differ = ColorizedReadableDiffer.new(from_lines, to_lines, self)
              if differ.need_diff?
                output("")
                output("diff:")
                differ.diff
              end
            end
          end

          def output_fault_in_short(fault)
            output_single("#{fault.label}: ")
            output_single(fault.message, fault_color(fault))
            output(" [#{fault.test_name}]")
            output(fault.location.first)
          end

          def format_fault(fault)
            fault.long_display
          end

          def output_statistics(elapsed_time)
            change_output_level(IMPORTANT_FAULTS_ONLY) do
              output("Finished in #{elapsed_time} seconds.")
            end
            output_summary_marker
            change_output_level(IMPORTANT_FAULTS_ONLY) do
              output(@result)
            end
            output("%g%% passed" % @result.pass_percentage)
            unless elapsed_time.zero?
              output_summary_marker
              test_throughput = @result.run_count / elapsed_time
              assertion_throughput = @result.assertion_count / elapsed_time
              throughput = [
                "%.2f tests/s" % test_throughput,
                "%.2f assertions/s" % assertion_throughput,
              ]
              output(throughput.join(", "))
            end
          end

          def output_summary_marker
            return if @progress_row_max <= 0
            output("-" * @progress_row_max, summary_marker_color)
          end

          def test_started(test)
            return unless output?(VERBOSE)

            tab_width = 8
            name = test.local_name
            separator = ":"
            left_used = indent.size + name.size + separator.size
            right_space = tab_width * 2
            left_space = @progress_row_max - right_space
            if (left_used % tab_width).zero?
              left_space -= left_used
              n_tabs = 0
            else
              left_space -= ((left_used / tab_width) + 1) * tab_width
              n_tabs = 1
            end
            n_tabs += [left_space, 0].max / tab_width
            tab_stop = "\t" * n_tabs
            output_single("#{indent}#{name}#{separator}#{tab_stop}",
                          nil,
                          VERBOSE)
            @test_start = Time.now
          end

          def test_finished(test)
            unless @already_outputted
              case @progress_style
              when :inplace
                mark = @progress_marks[@progress_mark_index]
                @progress_mark_index =
                  (@progress_mark_index + 1) % @progress_marks.size
                output_progress(mark, color("pass-marker"))
              when :mark
                output_progress(".", color("pass-marker"))
              end
            end
            @already_outputted = false

            return unless output?(VERBOSE)

            output(": (%f)" % (Time.now - @test_start), nil, VERBOSE)
          end

          def suite_name(prefix, suite)
            name = suite.name
            if name.nil?
              "(anonymous)"
            else
              name.sub(/\A#{Regexp.escape(prefix)}/, "")
            end
          end

          def test_suite_started(suite)
            last_test_suite = @test_suites.last
            @test_suites << suite
            if @top_level
              @top_level = false
              return
            end

            output_single(indent, nil, VERBOSE)
            if suite.test_case.nil?
              _color = color("suite")
            else
              _color = color("case")
            end
            prefix = "#{last_test_suite.name}::"
            output_single(suite_name(prefix, suite), _color, VERBOSE)
            output(": ", nil, VERBOSE)
            @indent += 2
          end

          def test_suite_finished(suite)
            @indent -= 2
            @test_suites.pop
          end

          def indent
            if output?(VERBOSE)
              " " * @indent
            else
              ""
            end
          end

          def nl(level=nil)
            output("", nil, level)
          end

          def output(something, color=nil, level=nil)
            return unless output?(level)
            output_single(something, color, level)
            @output.puts
          end

          def output_single(something, color=nil, level=nil)
            return false unless output?(level)
            something.to_s.each_line do |line|
              if @use_color and color
                line = "%s%s%s" % [color.escape_sequence,
                                   line,
                                   @reset_color.escape_sequence]
              end
              @output.write(line)
            end
            @output.flush
            true
          end

          def output_progress(mark, color=nil)
            if @progress_style == :inplace
              output_single("\r#{mark}", color, PROGRESS_ONLY)
            else
              return unless output?(PROGRESS_ONLY)
              output_single(mark, color)
              return unless @progress_row_max > 0
              @progress_row += mark.size
              if @progress_row >= @progress_row_max
                nl unless @output_level == VERBOSE
                @progress_row = 0
              end
            end
          end

          def output_progress_in_detail_marker(fault)
            return if @progress_row_max <= 0
            output("=" * @progress_row_max)
          end

          def output_progress_in_detail(fault)
            return if @output_level == SILENT
            need_detail_faults = (categorize_fault(fault) == :need_detail_faults)
            if need_detail_faults
              log_level = IMPORTANT_FAULTS_ONLY
            else
              log_level = @current_output_level
            end
            change_output_level(log_level) do
              nl(NORMAL)
              output_progress_in_detail_marker(fault)
              if need_detail_faults
                output_fault_in_detail(fault)
              else
                output_fault_in_short(fault)
              end
              output_progress_in_detail_marker(fault)
              @progress_row = 0
            end
          end

          def output?(level)
            (level || @current_output_level) <= @output_level
          end

          def color(name)
            _color = @color_scheme[name]
            _color ||= @color_scheme["success"] if name == "pass"
            _color ||= ColorScheme.default[name]
            _color
          end

          def fault_class_color_name(fault_class)
            fault_class.name.split(/::/).last.downcase
          end

          def fault_class_color(fault_class)
            color(fault_class_color_name(fault_class))
          end

          def fault_color(fault)
            fault_class_color(fault.class)
          end

          def fault_marker_color(fault)
            color("#{fault_class_color_name(fault.class)}-marker")
          end

          def summary_marker_color
            color("#{@result.status}-marker")
          end

          def guess_output_level
            if ENV["GITHUB_ACTIONS"] == "true"
              IMPORTANT_FAULTS_ONLY
            else
              NORMAL
            end
          end

          TERM_COLOR_SUPPORT = /
            color|  # explicitly claims color support in the name
            direct| # explicitly claims "direct color" (24 bit) support
            #{ColorScheme::TERM_256}|
            \Acygwin|
            \Alinux|
            \Ansterm-bce|
            \Ansterm-c-|
            \Aputty|
            \Arxvt|
            \Ascreen|
            \Atmux|
            \Axterm
          /x

          def guess_color_availability
            return true if ENV["GITHUB_ACTIONS"] == "true"
            return false unless @output.tty?
            return true if windows? and ruby_2_0_or_later?
            case ENV["TERM"]
            when /(?:term|screen)(?:-(?:256)?color)?\z/
              true
            when TERM_COLOR_SUPPORT
              true
            else
              return true if ENV["EMACS"] == "t"
              false
            end
          end

          def guess_progress_style
            if @output_level >= VERBOSE
              :mark
            else
              return :fault_only if ENV["GITHUB_ACTIONS"] == "true"
              return :fault_only unless @output.tty?
              :inplace
            end
          end

          def windows?
            /mswin|mingw/ === RUBY_PLATFORM
          end

          def ruby_2_0_or_later?
            RUBY_VERSION >= "2.0.0"
          end

          def guess_progress_row_max
            term_width = guess_term_width
            if term_width.zero?
              if ENV["EMACS"] == "t"
                -1
              else
                79
              end
            else
              term_width
            end
          end

          def guess_term_width
            guess_term_width_from_io || guess_term_width_from_env || 0
          end

          def guess_term_width_from_io
            if @output.respond_to?(:winsize)
              begin
                @output.winsize[1]
              rescue SystemCallError
                nil
              end
            else
              nil
            end
          end

          def guess_term_width_from_env
            env = ENV["COLUMNS"] || ENV["TERM_WIDTH"]
            return nil if env.nil?

            begin
              Integer(env)
            rescue ArgumentError
              nil
            end
          end
        end

        class ColorizedReadableDiffer < Diff::ReadableDiffer
          def initialize(from, to, runner)
            @runner = runner
            super(from, to)
          end

          def need_diff?(options={})
            return false if one_line_all_change?
            operations.each do |tag,|
              return true if [:replace, :equal].include?(tag)
            end
            false
          end

          private
          def one_line_all_change?
            return false if operations.size != 1

            tag, from_start, from_end, to_start, to_end = operations.first
            return false if tag != :replace
            return false if [from_start, from_end] != [0, 1]
            return false if [from_start, from_end] != [to_start, to_end]

            _, _, _line_operations = line_operations(@from.first, @to.first)
            _line_operations.size == 1
          end

          def output_single(something, color=nil)
            @runner.__send__(:output_single, something, color)
          end

          def output(something, color=nil)
            @runner.__send__(:output, something, color)
          end

          def color(name)
            @runner.__send__(:color, name)
          end

          def cut_off_ratio
            0
          end

          def default_ratio
            0
          end

          def tag(mark, color_name, contents)
            _color = color(color_name)
            contents.each do |content|
              output_single(mark, _color)
              output_single(" ")
              output(content)
            end
          end

          def tag_deleted(contents)
            tag("-", "diff-deleted-tag", contents)
          end

          def tag_inserted(contents)
            tag("+", "diff-inserted-tag", contents)
          end

          def tag_equal(contents)
            tag(" ", "normal", contents)
          end

          def tag_difference(contents)
            tag("?", "diff-difference-tag", contents)
          end

          def diff_line(from_line, to_line)
            to_operations = []
            mark_operations = []
            from_line, to_line, _operations = line_operations(from_line, to_line)

            no_replace = true
            _operations.each do |tag,|
              if tag == :replace
                no_replace = false
                break
              end
            end

            output_single("?", color("diff-difference-tag"))
            output_single(" ")
            _operations.each do |tag, from_start, from_end, to_start, to_end|
              from_width = compute_width(from_line, from_start, from_end)
              to_width = compute_width(to_line, to_start, to_end)
              case tag
              when :replace
                output_single(from_line[from_start...from_end],
                              color("diff-deleted"))
                if (from_width < to_width)
                  output_single(" " * (to_width - from_width))
                end
                to_operations << Proc.new do
                  output_single(to_line[to_start...to_end],
                                color("diff-inserted"))
                  if (to_width < from_width)
                    output_single(" " * (from_width - to_width))
                  end
                end
                mark_operations << Proc.new do
                  output_single("?" * from_width,
                                color("diff-difference-tag"))
                  if (to_width < from_width)
                    output_single(" " * (from_width - to_width))
                  end
                end
              when :delete
                output_single(from_line[from_start...from_end],
                              color("diff-deleted"))
                unless no_replace
                  to_operations << Proc.new {output_single(" " * from_width)}
                  mark_operations << Proc.new do
                    output_single("-" * from_width,
                                  color("diff-deleted"))
                  end
                end
              when :insert
                if no_replace
                  output_single(to_line[to_start...to_end],
                                color("diff-inserted"))
                else
                  output_single(" " * to_width)
                  to_operations << Proc.new do
                    output_single(to_line[to_start...to_end],
                                  color("diff-inserted"))
                  end
                  mark_operations << Proc.new do
                    output_single("+" * to_width,
                                  color("diff-inserted"))
                  end
                end
              when :equal
                output_single(from_line[from_start...from_end])
                unless no_replace
                  to_operations << Proc.new {output_single(" " * to_width)}
                  mark_operations << Proc.new {output_single(" " * to_width)}
                end
              else
                raise "unknown tag: #{tag}"
              end
            end
            output("")

            unless to_operations.empty?
              output_single("?", color("diff-difference-tag"))
              output_single(" ")
              to_operations.each do |operation|
                operation.call
              end
              output("")
            end

            unless mark_operations.empty?
              output_single("?", color("diff-difference-tag"))
              output_single(" ")
              mark_operations.each do |operation|
                operation.call
              end
              output("")
            end
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/emacs/000077500000000000000000000000001456346657200177115ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/ui/emacs/testrunner.rb000066400000000000000000000025321456346657200224510ustar00rootroot00000000000000require 'test/unit/ui/console/testrunner'

module Test
  module Unit
    module UI
      module Emacs
        class TestRunner < Console::TestRunner
          private
          def output_setup_end
          end

          def output_started
          end

          def format_fault(fault)
            return super unless fault.respond_to?(:label)
            format_method_name = "format_fault_#{fault.label.downcase}"
            if respond_to?(format_method_name, true)
              __send__(format_method_name, fault)
            else
              super
            end
          end

          def format_fault_failure(failure)
            if failure.location.size == 1
              location = failure.location[0]
              location_display = location.sub(/\A(.+:\d+).*/, ' [\\1]')
            else
              location_display = "\n" + failure.location.join("\n")
            end
            result = "#{failure.label}:\n"
            result += "#{failure.test_name}#{location_display}:\n"
            result += failure.message
            result
          end

          def format_fault_error(error)
            result = "#{error.label}:\n"
            result += "#{error.test_name}:\n"
            result += "#{error.message}\n"
            result += error.backtrace.join("\n")
            result
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/testrunner.rb000066400000000000000000000022451456346657200213620ustar00rootroot00000000000000require 'test/unit/ui/testrunnerutilities'

module Test
  module Unit
    module UI
      class TestRunner
        extend TestRunnerUtilities

        attr_reader :listeners
        def initialize(suite, options={})
          if suite.respond_to?(:suite)
            @suite = suite.suite
          else
            @suite = suite
          end
          @options = options
          @listeners = @options[:listeners] || []
        end

        # Begins the test run.
        def start
          setup_mediator
          attach_to_mediator
          attach_listeners
          start_mediator
        end

        private
        def setup_mediator
          @mediator = TestRunnerMediator.new(@suite)
        end

        def attach_listeners
          @listeners.each do |listener|
            listener.attach_to_mediator(@mediator)
          end
        end

        def start_mediator
          @mediator.run
        end

        def diff_target_string?(string)
          Assertions::AssertionMessage.diff_target_string?(string)
        end

        def prepare_for_diff(from, to)
          Assertions::AssertionMessage.prepare_for_diff(from, to)
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/testrunnermediator.rb000066400000000000000000000065161456346657200231140ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/util/observable'
require 'test/unit/testresult'

module Test
  module Unit
    module UI

      # Provides an interface to write any given UI against,
      # hopefully making it easy to write new UIs.
      class TestRunnerMediator
        RESET = name + "::RESET"
        STARTED = name + "::STARTED"
        FINISHED = name + "::FINISHED"

        include Util::Observable

        # Creates a new TestRunnerMediator initialized to run
        # the passed suite.
        def initialize(suite)
          @suite = suite
        end

        # Runs the suite the TestRunnerMediator was created
        # with.
        def run
          AutoRunner.need_auto_run = false

          result = create_result

          Test::Unit.run_at_start_hooks
          start_time = Time.now
          begin
            catch do |stop_tag|
              result.stop_tag = stop_tag
              with_listener(result) do
                notify_listeners(RESET, @suite.size)
                notify_listeners(STARTED, result)

                run_suite(result)
              end
            end
          ensure
            elapsed_time = Time.now - start_time
            notify_listeners(FINISHED, elapsed_time)
          end
          Test::Unit.run_at_exit_hooks

          result
        end

        # Just for backward compatibility for NetBeans.
        # NetBeans should not use monkey patching. NetBeans
        # should use runner change public API.
        #
        # See GitHub#38
        #   https://github.com/test-unit/test-unit/issues/38
        def run_suite(result=nil)
          if result.nil?
            run
          else
            @suite.run(result) do |channel, value|
              notify_listeners(channel, value)
            end
          end
        end

        private
        # A factory method to create the result the mediator
        # should run with. Can be overridden by subclasses if
        # one wants to use a different result.
        def create_result
          TestResult.new
        end

        def measure_time
          begin_time = Time.now
          yield
          Time.now - begin_time
        end

        def with_listener(result)
          finished_listener = result.add_listener(TestResult::FINISHED) do |*args|
            notify_listeners(TestResult::FINISHED, *args)
          end
          changed_listener = result.add_listener(TestResult::CHANGED) do |*args|
            notify_listeners(TestResult::CHANGED, *args)
          end
          pass_assertion_listener = result.add_listener(TestResult::PASS_ASSERTION) do |*args|
            notify_listeners(TestResult::PASS_ASSERTION, *args)
          end
          fault_listener = result.add_listener(TestResult::FAULT) do |*args|
            notify_listeners(TestResult::FAULT, *args)
          end

          begin
            yield
          ensure
            result.remove_listener(TestResult::FAULT, fault_listener)
            result.remove_listener(TestResult::CHANGED, changed_listener)
            result.remove_listener(TestResult::FINISHED, finished_listener)
            result.remove_listener(TestResult::PASS_ASSERTION,
                                   pass_assertion_listener)
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/testrunnerutilities.rb000066400000000000000000000020441456346657200233130ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

module Test
  module Unit
    module UI

      # Provides some utilities common to most, if not all,
      # TestRunners.
      #
      #--
      #
      # Perhaps there ought to be a TestRunner superclass? There
      # seems to be a decent amount of shared code between test
      # runners.

      module TestRunnerUtilities

        # Creates a new TestRunner and runs the suite.
        def run(suite, options={})
          return new(suite, options).start
        end

        # Takes care of the ARGV parsing and suite
        # determination necessary for running one of the
        # TestRunners from the command line.
        def start_command_line_test
          if ARGV.empty?
            puts "You should supply the name of a test suite file to the runner"
            exit
          end
          require ARGV[0].gsub(/.+::/, '')
          new(eval(ARGV[0])).start
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/ui/xml/000077500000000000000000000000001456346657200174215ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/ui/xml/testrunner.rb000066400000000000000000000157551456346657200221740ustar00rootroot00000000000000#--
#
# Author:: Kouhei Sutou
# Copyright::
#   * Copyright (c) 2011 Kouhei Sutou 
# License:: Ruby license.

require 'erb'
require 'time'
require 'test/unit/ui/testrunner'
require 'test/unit/ui/testrunnermediator'

module Test
  module Unit
    module UI
      module XML

        # Runs a Test::Unit::TestSuite and outputs XML.
        class TestRunner < UI::TestRunner
          include ERB::Util

          # Creates a new TestRunner for running the passed
          # suite. :output option specifies where runner
          # output should go to; defaults to STDOUT.
          def initialize(suite, options={})
            super
            @output = @options[:output] || STDOUT
            if @options[:output_file_descriptor]
              @output = IO.new(@options[:output_file_descriptor], "w")
            end
            @already_outputted = false
            @indent = 0
            @top_level = true
            @current_test = nil
            @current_test_suite = nil
            @already_outputted = false
          end

          private
          def attach_to_mediator
            @mediator.add_listener(TestResult::PASS_ASSERTION,
                                   &method(:result_pass_assertion))
            @mediator.add_listener(TestResult::FAULT,
                                   &method(:result_fault))
            @mediator.add_listener(TestRunnerMediator::STARTED,
                                   &method(:started))
            @mediator.add_listener(TestRunnerMediator::FINISHED,
                                   &method(:finished))
            @mediator.add_listener(TestCase::STARTED_OBJECT,
                                   &method(:test_started))
            @mediator.add_listener(TestCase::FINISHED_OBJECT,
                                   &method(:test_finished))
            @mediator.add_listener(TestSuite::STARTED_OBJECT,
                                   &method(:test_suite_started))
            @mediator.add_listener(TestSuite::FINISHED_OBJECT,
                                   &method(:test_suite_finished))
          end

          def result_pass_assertion(result)
            open_tag("pass-assertion") do
              output_test(@current_test)
            end
          end

          def result_fault(fault)
            open_tag("test-result") do
              open_tag("result") do
                output_test_suite(@current_test_suite)
                output_test(@current_test)
                open_tag("backtrace") do
                  fault.location.each do |entry|
                    file, line, info = entry.split(/:/, 3)
                    open_tag("entry") do
                      add_content("file", file)
                      add_content("line", line)
                      add_content("info", info)
                    end
                  end
                end
                if fault.respond_to?(:expected)
                  add_content("expected", fault.expected)
                end
                if fault.respond_to?(:actual)
                  add_content("actual", fault.actual)
                end
                add_content("detail", fault.message)
                add_content("status", fault.label.downcase)
              end
            end
            @already_outputted = true if fault.critical?
          end

          def started(result)
            @result = result
            output_started
          end

          def output_started
            open_tag("stream")
          end

          def finished(elapsed_time)
            add_content("success", @result.passed?)
            close_tag("stream")
          end

          def test_started(test)
            @already_outputted = false
            @current_test = test
            open_tag("start-test") do
              output_test(test)
            end
          end

          def test_finished(test)
            unless @already_outputted
              open_tag("test-result") do
                output_test(test)
                open_tag("result") do
                  output_test_suite(@current_test_suite)
                  output_test(test)
                  add_content("status", "success")
                end
              end
            end

            open_tag("complete-test") do
              output_test(test)
              add_content("success", test.passed?)
            end
            @current_test = nil
          end

          def test_suite_started(suite)
            @current_test_suite = suite
            if suite.test_case.nil?
              open_tag("ready-test-suite") do
                add_content("n-tests", suite.size)
              end
              open_tag("start-test-suite") do
                output_test_suite(suite)
              end
            else
              open_tag("ready-test-case") do
                output_test_suite(suite)
                add_content("n-tests", suite.size)
              end
              open_tag("start-test-case") do
                output_test_suite(suite)
              end
            end
          end

          def test_suite_finished(suite)
            if suite.test_case.nil?
              open_tag("complete-test-suite") do
                output_test_suite(suite)
                add_content("success", suite.passed?)
              end
            else
              open_tag("complete-test-case") do
                output_test_suite(suite)
                add_content("success", suite.passed?)
              end
            end
            @current_test_suite = nil
          end

          def indent
            " " * @indent
          end

          def open_tag(name)
            @output.puts("#{indent}<#{name}>")
            @indent += 2
            if block_given?
              yield
              close_tag(name)
            end
          end

          def add_content(name, content)
            return if content.nil?
            case content
            when Time
              content = content.iso8601
            end
            @output.puts("#{indent}<#{name}>#{h(content)}")
          end

          def close_tag(name)
            @indent -= 2
            @output.puts("#{indent}")
          end

          def output_test(test)
            open_tag("test") do
              add_content("name", test.method_name)
              add_content("start-time", test.start_time)
              add_content("elapsed", test.elapsed_time)
            end
          end

          def output_test_suite(test_suite)
            test_case = test_suite.test_case
            if test_case.nil?
              open_tag("test-suite") do
                add_content("name", test_suite.name)
                add_content("start-time", test_suite.start_time)
                add_content("elapsed", test_suite.elapsed_time)
              end
            else
              open_tag("test-case") do
                add_content("name", test_suite.name)
                add_content("start-time", test_suite.start_time)
                add_content("elapsed", test_suite.elapsed_time)
              end
            end
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/util/000077500000000000000000000000001456346657200171615ustar00rootroot00000000000000test-unit-3.6.2/lib/test/unit/util/backtracefilter.rb000066400000000000000000000034601456346657200226360ustar00rootroot00000000000000begin
  require 'power_assert'
rescue LoadError, SyntaxError
end

module Test
  module Unit
    module Util
      module BacktraceFilter
        TESTUNIT_FILE_SEPARATORS = %r{[\\/:]}
        TESTUNIT_PREFIX = __FILE__.split(TESTUNIT_FILE_SEPARATORS)[0..-3]
        TESTUNIT_RB_FILE = /\.rb\Z/

        POWERASSERT_PREFIX =
          defined?(::PowerAssert) ?
            ::PowerAssert.method(:start).source_location[0].split(TESTUNIT_FILE_SEPARATORS)[0..-2] :
            nil

        module_function
        def filter_backtrace(backtrace, prefix=nil)
          return ["No backtrace"] unless backtrace
          return backtrace if ENV["TEST_UNIT_ALL_BACKTRACE"]

          if prefix
            split_prefixes = [prefix.split(TESTUNIT_FILE_SEPARATORS)]
          else
            split_prefixes = [TESTUNIT_PREFIX, POWERASSERT_PREFIX].compact
          end
          test_unit_internal_p = lambda do |entry|
            components = entry.split(TESTUNIT_FILE_SEPARATORS)
            split_prefixes.any? do |split_prefix|
              split_entry = components[0, split_prefix.size]
              next false unless split_entry[0..-2] == split_prefix[0..-2]
              split_entry[-1].sub(TESTUNIT_RB_FILE, '') == split_prefix[-1]
            end
          end

          in_user_code = false
          new_backtrace = backtrace.reverse.reject do |entry|
            if test_unit_internal_p.call(entry)
              in_user_code = true
              true
            else
              not in_user_code
            end
          end.reverse

          if new_backtrace.empty?
            new_backtrace = backtrace.reject do |entry|
              test_unit_internal_p.call(entry)
            end
            new_backtrace = backtrace if new_backtrace.empty?
          end
          new_backtrace
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/util/memory-usage.rb000066400000000000000000000020271456346657200221210ustar00rootroot00000000000000module Test
  module Unit
    module Util
      class MemoryUsage
        attr_reader :virtual
        attr_reader :physical
        def initialize
          @virtual = nil
          @physical = nil
          collect_data
        end

        def collected?
          return false if @virtual.nil?
          return false if @physical.nil?
          true
        end

        private
        def collect_data
          collect_data_proc
        end

        def collect_data_proc
          status_file = "/proc/self/status"
          return false unless File.exist?(status_file)

          data = File.binread(status_file)
          data.each_line do |line|
            case line
            when /\AVm(Size|RSS):\s*(\d+)\s*kB/
              name = $1
              value = Integer($2, 10) * 1024
              case name
              when "Size"
                @virtual = value
              when "RSS"
                @physical = value
              end
            end
          end
          collected?
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/util/method-owner-finder.rb000066400000000000000000000013301456346657200233600ustar00rootroot00000000000000module Test
  module Unit
    module Util
      module MethodOwnerFinder
        module_function
        def find(object, method_name)
          method = object.method(method_name)
          return method.owner if method.respond_to?(:owner)

          if /\((.+?)\)\#/ =~ method.to_s
            owner_name = $1
            if /\A# ["stdout\n", "stderr\n"]
        def capture_output
          require 'stringio'

          output = StringIO.new
          error = StringIO.new
          stdout_save, stderr_save = $stdout, $stderr
          $stdout, $stderr = output, error
          begin
            yield
            [output.string, error.string]
          ensure
            $stdout, $stderr = stdout_save, stderr_save
          end
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/util/procwrapper.rb000066400000000000000000000021151456346657200220510ustar00rootroot00000000000000#--
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

module Test
  module Unit
    module Util

      # Allows the storage of a Proc passed through '&' in a
      # hash.
      #
      # Note: this may be inefficient, since the hash being
      # used is not necessarily very good. In Observable,
      # efficiency is not too important, since the hash is
      # only accessed when adding and removing listeners,
      # not when notifying.

      class ProcWrapper

        # Creates a new wrapper for a_proc.
        def initialize(a_proc)
          @a_proc = a_proc
          @hash = a_proc.inspect.sub(/^(#<#{a_proc.class}:)/){''}.sub(/(>)$/){''}.hex
        end

        def hash
          return @hash
        end

        def ==(other)
          case(other)
          when ProcWrapper
            return @a_proc == other.to_proc
          else
            return super
          end
        end
        alias :eql? :==

        def to_proc
          return @a_proc
        end
      end
    end
  end
end
test-unit-3.6.2/lib/test/unit/version.rb000066400000000000000000000000721456346657200202150ustar00rootroot00000000000000module Test
  module Unit
    VERSION = "3.6.2"
  end
end
test-unit-3.6.2/lib/test/unit/warning.rb000066400000000000000000000001251456346657200201740ustar00rootroot00000000000000if defined?(Warning) and Warning.respond_to?(:[]=)
  Warning[:deprecated] = true
end
test-unit-3.6.2/sample/000077500000000000000000000000001456346657200147615ustar00rootroot00000000000000test-unit-3.6.2/sample/adder.rb000066400000000000000000000003711456346657200163660ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

class Adder
  def initialize(number)
    @number = number
  end
  def add(number)
    @number + number
  end
end

test-unit-3.6.2/sample/subtracter.rb000066400000000000000000000004021456346657200174600ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

class Subtracter
  def initialize(number)
    @number = number
  end
  def subtract(number)
    @number - number
  end
end
test-unit-3.6.2/sample/test_adder.rb000066400000000000000000000006131456346657200174240ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'
require_relative 'adder'

class TestAdder < Test::Unit::TestCase
  def setup
    @adder = Adder.new(5)
  end

  def test_add
    assert_equal(7, @adder.add(2), "Should have added correctly")
  end

  def teardown
    @adder = nil
  end
end
test-unit-3.6.2/sample/test_subtracter.rb000066400000000000000000000006701456346657200205260ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'
require_relative 'subtracter'

class TestSubtracter < Test::Unit::TestCase
  def setup
    @subtracter = Subtracter.new(5)
  end

  def test_subtract
    assert_equal(3, @subtracter.subtract(2), "Should have subtracted correctly")
  end

  def teardown
    @subtracter = nil
  end
end
test-unit-3.6.2/sample/test_user.rb000066400000000000000000000005521456346657200173250ustar00rootroot00000000000000# nested test case example.
require 'test/unit'

class UserTest < Test::Unit::TestCase
  def setup
    @user = "me"
  end

  def test_full_name
    assert_equal("me", @user)
  end

  class ProfileTest < UserTest
    setup
    def setup_profile
      @user += ": profile"
    end

    def test_has_profile
      assert_match(/: profile/, @user)
    end
  end
end
test-unit-3.6.2/test-unit.gemspec000066400000000000000000000031441456346657200170030ustar00rootroot00000000000000# -*- mode: ruby; coding: utf-8 -*-
#
# Copyright (C) 2012-2013  Kouhei Sutou 

clean_white_space = lambda do |entry|
  entry.gsub(/(\A\n+|\n+\z)/, '') + "\n"
end

base_dir = File.dirname(__FILE__)
$LOAD_PATH.unshift(File.join(base_dir, "lib"))
require "test/unit/version"

version = Test::Unit::VERSION.dup

Gem::Specification.new do |spec|
  spec.name = "test-unit"
  spec.version = version
  spec.homepage = "https://test-unit.github.io/"
  spec.authors = ["Kouhei Sutou", "Haruka Yoshihara"]
  spec.email = ["kou@cozmixng.org", "yoshihara@clear-code.com"]
  readme = File.read("README.md")
  readme.force_encoding("UTF-8") if readme.respond_to?(:force_encoding)
  entries = readme.split(/^\#\#\s(.*)$/)
  description = clean_white_space.call(entries[entries.index("Description") + 1])
  spec.summary, spec.description, = description.split(/\n\n+/, 3)
  spec.licenses = ["Ruby", "BSDL", "PSFL"] # lib/test/unit/diff.rb is PSFL
  spec.files = ["README.md", "Rakefile"]
  spec.files += ["COPYING", "BSDL", "PSFL"]
  spec.files += Dir.glob("{lib,sample}/**/*.rb")
  spec.files += Dir.glob("doc/text/**/*.*")

  spec.metadata = {
    "source_code_uri" => "https://github.com/test-unit/test-unit",
    "documentation_uri" => "https://test-unit.github.io/test-unit/en/",
    "bug_tracker_uri" => "https://github.com/test-unit/test-unit/issues"
  }

  spec.add_runtime_dependency("power_assert")
  spec.add_development_dependency("bundler")
  spec.add_development_dependency("rake")
  spec.add_development_dependency("yard")
  spec.add_development_dependency("kramdown")
  spec.add_development_dependency("packnga")
end
test-unit-3.6.2/test/000077500000000000000000000000001456346657200144575ustar00rootroot00000000000000test-unit-3.6.2/test/collector/000077500000000000000000000000001456346657200164455ustar00rootroot00000000000000test-unit-3.6.2/test/collector/test-descendant.rb000066400000000000000000000141201456346657200220550ustar00rootroot00000000000000require 'test/unit'
require 'test/unit/collector/descendant'

class TestUnitCollectorDescendant < Test::Unit::TestCase
  def setup
    @previous_descendants = Test::Unit::TestCase::DESCENDANTS.dup
    Test::Unit::TestCase::DESCENDANTS.clear
  end

  def teardown
    Test::Unit::TestCase::DESCENDANTS.replace(@previous_descendants)
  end

  private
  def assert_collect(expected, *collect_args)
    collector = Test::Unit::Collector::Descendant.new
    yield(collector) if block_given?
    assert_equal(expected, collector.send(:collect, *collect_args))
  end

  def default_name
    Test::Unit::Collector::Descendant::NAME
  end

  def empty_suite(name=nil)
    Test::Unit::TestSuite.new(name || default_name)
  end

  class TestCollect < self
    def setup
      super

      @test_case1 = Class.new(Test::Unit::TestCase) do
        self.test_order = :alphabetic

        def self.name
          "test-case1"
        end

        def test_1
        end

        def test_2
        end
      end

      @test_case2 = Class.new(Test::Unit::TestCase) do
        self.test_order = :alphabetic

        def self.name
          "test-case2"
        end

        def test_0
        end
      end

      @no_test_case = Class.new do
        def self.name
          "no-test-case"
        end

        def test_4
        end
      end
    end

    def test_basic
      assert_collect(full_suite("name"), "name")

      assert_collect(full_suite("name"), "name") do |collector|
        collector.filter = []
      end
    end

    def test_filtered
      assert_collect(empty_suite) do |collector|
        collector.filter = Proc.new {false}
      end

      assert_collect(full_suite) do |collector|
        collector.filter = Proc.new {true}
      end

      assert_collect(full_suite) do |collector|
        collector.filter = Proc.new {nil}
      end

      assert_collect(empty_suite) do |collector|
        collector.filter = [Proc.new {false}, Proc.new {true}]
      end

      assert_collect(empty_suite) do |collector|
        collector.filter = [Proc.new {true}, Proc.new {false}]
      end

      assert_collect(empty_suite) do |collector|
        collector.filter = [Proc.new {nil}, Proc.new {false}]
      end

      assert_collect(full_suite) do |collector|
        collector.filter = [Proc.new {nil}, Proc.new {true}]
      end

      expected = empty_suite
      suite1 = Test::Unit::TestSuite.new(@test_case1.name)
      suite1 << @test_case1.new("test_1")
      suite2 = Test::Unit::TestSuite.new(@test_case2.name)
      suite2 << @test_case2.new("test_0")
      expected << suite1 << suite2
      assert_collect(expected) do |collector|
        collector.filter = Proc.new do |test|
          ['test_1', 'test_0'].include?(test.method_name)
        end
      end

      suite1 = Test::Unit::TestSuite.new(@test_case1.name)
      suite1 << @test_case1.new("test_1")
      suite2 = Test::Unit::TestSuite.new(@test_case2.name)
      suite2 << @test_case2.new("test_0")
      assert_collect(empty_suite) do |collector|
        filters = [Proc.new {|test| test.method_name == 'test_1' ? true : nil},
                   Proc.new {|test| test.method_name == 'test_0' ? true : nil},
                   Proc.new {false}]
        collector.filter = filters
      end
    end

    private
    def full_suite(name=nil)
      sub_suite1 = Test::Unit::TestSuite.new(@test_case1.name)
      sub_suite1 << @test_case1.new('test_1')
      sub_suite1 << @test_case1.new('test_2')

      sub_suite2 = Test::Unit::TestSuite.new(@test_case2.name)
      sub_suite2 << @test_case2.new('test_0')

      suite = empty_suite(name)
      suite << sub_suite1
      suite << sub_suite2
      suite
    end
  end

  class TestCollectRactor < self
    def setup
      super

      @test_case1 = Class.new(Test::Unit::TestCase) do
        self.test_order = :alphabetic

        def self.name
          "test-case-one-ractor-test"
        end

        def test_no_ractor_1_1
        end

        ractor
        def test_ractor_1_1
        end

        def test_no_ractor_1_2
        end
      end

      @test_case2 = Class.new(Test::Unit::TestCase) do
        self.test_order = :alphabetic

        def self.name
          "test-case-two-ractor-tests"
        end

        def test_no_ractor_2_1
        end

        ractor keep: true
        def test_ractor_2_1
        end

        def test_ractor_2_2
        end
      end
    end

    def test_sort
      assert_collect(full_suite("name"), "name")
    end

    private
    def full_suite(name=nil)
      sub_suite_no_ractor1 = Test::Unit::TestSuite.new(@test_case1.name)
      sub_suite_no_ractor1 << @test_case1.new('test_no_ractor_1_1')
      sub_suite_no_ractor1 << @test_case1.new('test_no_ractor_1_2')
      sub_suite_ractor1 = Test::Unit::TestSuite.new(@test_case1.name)
      sub_suite_ractor1 << @test_case1.new('test_ractor_1_1')

      sub_suite_no_ractor2 = Test::Unit::TestSuite.new(@test_case2.name)
      sub_suite_no_ractor2 << @test_case2.new('test_no_ractor_2_1')
      sub_suite_ractor2 = Test::Unit::TestSuite.new(@test_case2.name)
      sub_suite_ractor2 << @test_case2.new('test_ractor_2_1')
      sub_suite_ractor2 << @test_case2.new('test_ractor_2_2')

      suite = empty_suite(name)
      suite << sub_suite_no_ractor1
      suite << sub_suite_no_ractor2
      suite << sub_suite_ractor1
      suite << sub_suite_ractor2
      suite
    end
  end

  class TestModule < self
    def test_included_in_child
      tests = Module.new do
        def test_in_module
        end
      end

      parent_test_case = Class.new(Test::Unit::TestCase) do
        class << self
          def name
            "Parent"
          end
        end
      end

      child_test_case = Class.new(parent_test_case) do
        include tests

        class << self
          def name
            "Child"
          end
        end
      end

      child_suite = Test::Unit::TestSuite.new(child_test_case.name)
      child_suite << child_test_case.new("test_in_module")

      parent_suite = Test::Unit::TestSuite.new(parent_test_case.name)
      parent_suite << child_suite

      suite = empty_suite("all")
      suite << parent_suite

      assert_collect(suite, "all")
    end
  end
end
test-unit-3.6.2/test/collector/test-load.rb000066400000000000000000000333361456346657200206760ustar00rootroot00000000000000require 'tmpdir'
require 'pathname'

require 'test/unit'
require 'test/unit/collector/load'

class TestUnitCollectorLoad < Test::Unit::TestCase
  def setup
    @previous_descendants = Test::Unit::TestCase::DESCENDANTS.dup
    Test::Unit::TestCase::DESCENDANTS.clear

    @temporary_test_cases_module_name = "TempTestCases"
    ::Object.const_set(@temporary_test_cases_module_name, Module.new)

    @test_dir = Pathname(Dir.tmpdir) + "test-unit"
    @extra_test_dir = Pathname(Dir.tmpdir) + "test-unit-extra"
    ensure_clean_directory(@test_dir)
    ensure_clean_directory(@extra_test_dir)
  end

  setup
  def setup_top_level_test_cases
    @test_case1_base_name = "test_case1.rb"

    @test_case1 = @test_dir + @test_case1_base_name
    @test_case2 = @test_dir + "test_case2.rb"
    @no_load_test_case3 = @test_dir + "case3.rb"

    @test_case1.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class TestCase1 < Test::Unit::TestCase
    def test1_1
    end

    def test1_2
    end
  end
end
EOT
    end

    @test_case2.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class TestCase2 < Test::Unit::TestCase
    def test2
    end
  end
end
EOT
    end

    @no_load_test_case3.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class NoLoadTestCase3 < Test::Unit::TestCase
    def test3
    end
  end
end
EOT
    end
  end

  setup
  def setup_sub_level_test_cases
    @sub_test_dir = @test_dir + "sub"
    @sub_test_dir.mkpath

    @sub_test_case1 = @sub_test_dir + @test_case1_base_name
    @sub_test_case4 = @sub_test_dir + "test_case4.rb"
    @no_load_sub_test_case5 = @sub_test_dir + "case5.rb"
    @sub_test_case6 = @sub_test_dir + "test_case6.rb"

    @sub_test_case1.open("w") do |test_case|
      test_case.puts(<<-TEST_CASE)
module #{@temporary_test_cases_module_name}
  class SubTestCase1 < Test::Unit::TestCase
    def test1_1
    end

    def test1_2
    end
  end
end
      TEST_CASE
    end

    @sub_test_case4.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SubTestCase4 < Test::Unit::TestCase
    def test4_1
    end

    def test4_2
    end
  end
end
EOT
    end

    @no_load_sub_test_case5.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class NoLoadSubTestCase5 < Test::Unit::TestCase
    def test5_1
    end

    def test5_2
    end
  end
end
EOT
    end

    @sub_test_case6.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SubTestCase6 < Test::Unit::TestCase
    def test6
    end
  end
end
EOT
    end
  end

  setup
  def setup_sub_level_test_cases2
    @sub2_test_dir = @test_dir + "sub2"
    @sub2_test_dir.mkpath

    @no_load_sub2_test_case7 = @sub2_test_dir + "case7.rb"
    @sub2_test_case8 = @sub2_test_dir + "test_case8.rb"
    @sub2_test_case9 = @sub2_test_dir + "test_case9.rb"

    @no_load_sub2_test_case7.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class NoLoadSub2TestCase7 < Test::Unit::TestCase
    def test7_1
    end

    def test7_2
    end
  end
end
EOT
    end

    @sub2_test_case8.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class Sub2TestCase8 < Test::Unit::TestCase
    def test8_1
    end

    def test8_2
    end
  end
end
EOT
    end

    @sub2_test_case9.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class Sub2TestCase9 < Test::Unit::TestCase
    def test9
    end
  end
end
EOT
    end
  end

  setup
  def setup_svn_test_cases
    @svn_test_dir = @test_dir + ".svn"
    @svn_test_dir.mkpath

    @svn_test_case10 = @svn_test_dir + "test_case10.rb"

    @svn_test_case10.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SvnTestCase10 < Test::Unit::TestCase
    def test7
    end
  end
end
EOT
    end
  end

  setup
  def setup_sub_cvs_test_cases
    @sub_cvs_test_dir = @sub_test_dir + "CVS"
    @sub_cvs_test_dir.mkpath

    @sub_cvs_test_case11 = @sub_cvs_test_dir + "test_case11.rb"

    @sub_cvs_test_case11.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SubCVSTestCase11 < Test::Unit::TestCase
    def test11
    end
  end
end
EOT
    end
  end

  setup
  def setup_sub_git_test_cases
    @sub_git_test_dir = @sub_test_dir + ".git"
    @sub_git_test_dir.mkpath

    @sub_git_test_case11 = @sub_git_test_dir + "test_case11.rb"

    @sub_git_test_case11.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SubGitTestCase11 < Test::Unit::TestCase
    def test11
    end
  end
end
EOT
    end
  end

  setup
  def setup_extra_top_level_test_cases
    @test_cases12 = @extra_test_dir + "test_cases12.rb"
    @test_cases12.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class TestCase121 < Test::Unit::TestCase
    def test121_1
    end

    def test121_2
    end
  end

  class TestCase122 < Test::Unit::TestCase
    def test122_1
    end

    def test122_2
    end
  end
end
EOT
    end
  end

  setup
  def setup_sub_level_extra_test_cases
    @sub_extra_test_dir = @extra_test_dir + "sub"
    @sub_extra_test_dir.mkpath

    @cases13_test = @sub_extra_test_dir + "13cases_test.rb"
    @cases13_test.open("w") do |test_case|
      test_case.puts(<<-EOT)
module #{@temporary_test_cases_module_name}
  class SubTestCase13 < Test::Unit::TestCase
    def test13_1
    end

    def test13_2
    end
  end
end
EOT
    end
  end

  def teardown
    @test_dir.rmtree if @test_dir.exist?
    ::Object.send(:remove_const, @temporary_test_cases_module_name)
    Test::Unit::TestCase::DESCENDANTS.replace(@previous_descendants)
  end

  def test_simple_collect
    assert_collect([:suite, {:name => @sub_test_dir.basename.to_s},
                    [:suite, {:name => _test_case_name("SubTestCase1")},
                     [:test, {:name => "test1_1"}],
                     [:test, {:name => "test1_2"}]],
                    [:suite, {:name => _test_case_name("SubTestCase4")},
                     [:test, {:name => "test4_1"}],
                     [:test, {:name => "test4_2"}]],
                    [:suite, {:name => _test_case_name("SubTestCase6")},
                     [:test, {:name => "test6"}]]],
                   @sub_test_dir.to_s)
  end

  def test_simple_collect_test_suffix
    assert_collect([:suite, {:name => @extra_test_dir.basename.to_s},
                    [:suite, {:name => _test_case_name("TestCase121")},
                     [:test, {:name => "test121_1"}],
                     [:test, {:name => "test121_2"}]],
                    [:suite, {:name => _test_case_name("TestCase122")},
                     [:test, {:name => "test122_1"}],
                     [:test, {:name => "test122_2"}]],
                    [:suite, {:name => @sub_extra_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("SubTestCase13")},
                      [:test, {:name => "test13_1"}],
                      [:test, {:name => "test13_2"}]]]],
                   @extra_test_dir.to_s)
  end

  def test_multilevel_collect
    assert_collect([:suite, {:name => "."},
                    [:suite, {:name => _test_case_name("TestCase1")},
                     [:test, {:name => "test1_1"}],
                     [:test, {:name => "test1_2"}]],
                    [:suite, {:name => _test_case_name("TestCase2")},
                     [:test, {:name => "test2"}]],
                    [:suite, {:name => @sub_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("SubTestCase1")},
                      [:test, {:name => "test1_1"}],
                      [:test, {:name => "test1_2"}]],
                     [:suite, {:name => _test_case_name("SubTestCase4")},
                      [:test, {:name => "test4_1"}],
                      [:test, {:name => "test4_2"}]],
                     [:suite, {:name => _test_case_name("SubTestCase6")},
                      [:test, {:name => "test6"}]]],
                   [:suite, {:name => @sub2_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("Sub2TestCase8")},
                      [:test, {:name => "test8_1"}],
                      [:test, {:name => "test8_2"}]],
                     [:suite, {:name => _test_case_name("Sub2TestCase9")},
                      [:test, {:name => "test9"}]]]])
  end

  def test_collect_file
    assert_collect([:suite, {:name => _test_case_name("TestCase1")},
                    [:test, {:name => "test1_1"}],
                    [:test, {:name => "test1_2"}]],
                   @test_case1.to_s)
  end

  def test_collect_file_no_pattern_match_file_name
    assert_collect([:suite, {:name => _test_case_name("NoLoadSubTestCase5")},
                    [:test, {:name => "test5_1"}],
                    [:test, {:name => "test5_2"}]],
                   @no_load_sub_test_case5.to_s)
  end

  def test_collect_file_test_cases
    assert_collect([:suite, {:name => "[#{@test_cases12}]"},
                    [:suite, {:name => _test_case_name("TestCase121")},
                     [:test, {:name => "test121_1"}],
                     [:test, {:name => "test121_2"}]],
                    [:suite, {:name => _test_case_name("TestCase122")},
                     [:test, {:name => "test122_1"}],
                     [:test, {:name => "test122_2"}]]],
                   @test_cases12.to_s)
  end

  def test_collect_files
    assert_collect([:suite,
                    {:name => "[#{@test_case1}, #{@test_case2}]"},
                    [:suite, {:name => _test_case_name("TestCase1")},
                     [:test, {:name => "test1_1"}],
                     [:test, {:name => "test1_2"}]],
                    [:suite, {:name => _test_case_name("TestCase2")},
                     [:test, {:name => "test2"}]]],
                   @test_case1.to_s, @test_case2.to_s)
  end

  def test_nil_pattern
    assert_collect([:suite, {:name => @sub_test_dir.basename.to_s},
                    [:suite, {:name => _test_case_name("NoLoadSubTestCase5")},
                     [:test, {:name => "test5_1"}],
                     [:test, {:name => "test5_2"}]],
                    [:suite, {:name => _test_case_name("SubTestCase1")},
                     [:test, {:name => "test1_1"}],
                     [:test, {:name => "test1_2"}]],
                    [:suite, {:name => _test_case_name("SubTestCase4")},
                     [:test, {:name => "test4_1"}],
                     [:test, {:name => "test4_2"}]],
                    [:suite, {:name => _test_case_name("SubTestCase6")},
                     [:test, {:name => "test6"}]]],
                   @sub_test_dir.to_s) do |collector|
      collector.patterns.clear
    end
  end

  def test_filtering
    assert_collect([:suite, {:name => "."},
                    [:suite, {:name => _test_case_name("TestCase1")},
                     [:test, {:name => "test1_1"}],
                     [:test, {:name => "test1_2"}]],
                    [:suite, {:name => @sub_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("SubTestCase1")},
                      [:test, {:name => "test1_1"}],
                      [:test, {:name => "test1_2"}]]]]) do |collector|
      collector.filter = Proc.new do |test|
        !/\Atest1/.match(test.method_name).nil?
      end
    end
  end

  def test_collect_multi
    test_dirs = [@sub_test_dir.to_s, @sub2_test_dir.to_s]
    assert_collect([:suite, {:name => "[#{test_dirs.join(', ')}]"},
                    [:suite, {:name => @sub_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("SubTestCase1")},
                      [:test, {:name => "test1_1"}],
                      [:test, {:name => "test1_2"}]],
                     [:suite, {:name => _test_case_name("SubTestCase4")},
                      [:test, {:name => "test4_1"}],
                      [:test, {:name => "test4_2"}]],
                     [:suite, {:name => _test_case_name("SubTestCase6")},
                      [:test, {:name => "test6"}]]],
                    [:suite, {:name => @sub2_test_dir.basename.to_s},
                     [:suite, {:name => _test_case_name("Sub2TestCase8")},
                      [:test, {:name => "test8_1"}],
                      [:test, {:name => "test8_2"}]],
                     [:suite, {:name => _test_case_name("Sub2TestCase9")},
                      [:test, {:name => "test9"}]]]],
                   *test_dirs)
  end

  private
  def assert_collect(expected, *collect_args)
    keep_required_files do
      Dir.chdir(@test_dir.to_s) do
        collector = Test::Unit::Collector::Load.new
        yield(collector) if block_given?
        actual = inspect_test_object(collector.send(:collect, *collect_args))
        assert_equal(expected, actual)
      end
    end
  end

  def ensure_clean_directory(directory)
    directory.rmtree if directory.exist?
    directory.mkpath
  end

  def keep_required_files
    required_files = $".dup
    yield
  ensure
    $".replace(required_files)
  end

  def _test_case_name(test_case_class_name)
    "#{@temporary_test_cases_module_name}::#{test_case_class_name}"
  end

  def inspect_test_object(test_object)
    return nil if test_object.nil?
    case test_object
    when Test::Unit::TestSuite
      sub_tests = test_object.tests.collect do |test|
        inspect_test_object(test)
      end.sort_by do |type, attributes, *children|
        attributes[:name]
      end
      [:suite, {:name => test_object.name}, *sub_tests]
    when Test::Unit::TestCase
      [:test, {:name => test_object.method_name}]
    else
      raise "unexpected test object: #{test_object.inspect}"
    end
  end
end
test-unit-3.6.2/test/collector/test_dir.rb000066400000000000000000000253271456346657200206200ustar00rootroot00000000000000require 'test/unit'
require 'test/unit/collector/dir'
require 'pp'

module Test
  module Unit
    module Collector
      class TestDir < TestCase
        class FileSystem
          class Directory
            def initialize(name, fs, parent=self, &block)
              @name = name
              @fs = fs
              @parent = parent
              @contents = {'.' => self, '..' => parent}
              instance_eval(&block) if(block)
            end

            def file(name, contents)
              @contents[name] = contents
            end

            def dir(name, &block)
              @contents[name] = self.class.new(name, @fs, self, &block)
            end

            def entries
              @contents.keys
            end

            def directory?(name)
              return true if(name.nil? || name.empty?)
              return false unless(@contents.include?(name))
              @contents[name].kind_of?(self.class)
            end

            def file?(name)
              return false unless(@contents.include?(name))
              !directory?(name)
            end

            def exist?(name)
              @contents.include?(name)
            end

            def [](name)
              raise Errno::ENOENT, name unless(@contents.include?(name))
              @contents[name]
            end

            def path_to(name=nil)
              if(!name)
                @parent.path_to(@name)
              elsif(@parent == self)
                @fs.join('/', name)
              else
                @fs.join(@parent.path_to(@name), name)
              end
            end
          end

          class ObjectSpace
            def initialize
              @objects = []
            end

            def each_object(klass, &block)
              @objects.find_all{|o| o.kind_of?(klass)}.each(&block)
            end

            def <<(object)
              @objects << object
            end
          end

          attr_reader :object_space

          def initialize(&block)
            @root = Directory.new('/', self, &block)
            @pwd = @root
            @object_space = ObjectSpace.new
            @required = []
          end

          def entries(dir)
            e = find(dir)
            require_directory(dir)
            e.entries
          end

          def directory?(name)
            return true if (base = basename(name)) == '/'
            e = find(dirname(name))
            return false unless(e)
            e.directory?(base)
          end

          def find(path)
            if(/\A\// =~ path)
              thing = @root
            else
              thing = @pwd
            end
            path.scan(/[^\/]+/) do |e|
              break thing = false unless(thing.kind_of?(Directory))
              thing = thing[e]
            end
            thing
          end

          def dirname(name)
            if (name = name.tr_s('/', '/')) == '/'
              name
            else
              name[%r"\A.+(?=/[^/]+/?\z)|\A/"] || "."
            end
          end

          def basename(name)
            name[%r"(\A/|[^/]+)/*\z", 1]
          end

          def split(name)
            [dirname(name), basename(name)]
          end

          def join(*parts)
            parts.join('/').gsub(%r{/+}, '/')
          end

          def file?(name)
            e = find(dirname(name))
            return false unless(e)
            e.file?(basename(name))
          end

          def pwd
            @pwd.path_to
          end

          def chdir(to)
            e = find(to)
            require_directory(to)
            @pwd = e
          end

          def expand_path(path, base = nil)
            until /\A\// =~ path
              base ||= pwd
              path = join(base, path)
              base = nil
            end
            path.gsub!(%r"(?:/\.)+(?=/)", '')
            nil while path.sub!(%r"/(?!\.\./)[^/]+/\.\.(?=/)", '')
            path.sub!(%r"\A(?:/\.\.)+(?=/)", '')
            path.sub!(%r"(?:\A(/)|/)\.\.?\z", '\1')
            path
          end

          def require_directory(path)
            raise Errno::ENOTDIR, path unless(directory?(path))
          end

          def require(file)
            return false if(@required.include?(file))
            begin
              e = find(file)
            rescue Errno::ENOENT => e
              if(/\.rb\Z/ =~ file)
                raise LoadError, file
              end
              e = find(file + '.rb')
            end
            @required << file
            @object_space << e
            true
          rescue Errno::ENOENT
            raise LoadError, file
          end
        end

        def test_dir
          inner_dir = nil
          dirs = FileSystem::Directory.new('/', nil) do
            file 'a', nil
            inner_dir = dir 'b'
          end
          assert_equal(inner_dir, dirs['b'])
        end

        def test_fs
          fs = FileSystem.new do
            file 'a', nil
            dir 'b'
          end
          assert_equal(['.', '..', 'a', 'b'].sort, fs.entries('/').sort)
          assert(fs.directory?('/'))
          assert(!fs.directory?('/a'))
          assert(!fs.directory?('/bogus'))
          assert(fs.file?('/a'))
          assert(!fs.file?('/'))
          assert(!fs.file?('/bogus'))
          assert(fs.directory?('/b'))
          assert(fs.file?('a'))
          assert(fs.directory?('b'))
        end

        def test_fs_sub
          fs = FileSystem.new do
            dir 'a' do
              file 'b', nil
              dir 'c' do
                file 'd', nil
              end
            end
          end
          assert(fs.file?('/a/b'))
          assert(!fs.file?('/a/b/c/d'))
          assert(fs.file?('/a/c/d'))
        end

        def test_fs_pwd
          fs = FileSystem.new do
            file 'a', nil
            dir 'b' do
              file 'c', nil
              dir 'd' do
                file 'e', nil
              end
            end
          end
          assert_equal('/', fs.pwd)
          assert_raises(Errno::ENOENT) do
            fs.chdir('bogus')
          end
          assert_raises(Errno::ENOTDIR) do
            fs.chdir('a')
          end
          fs.chdir('b')
          assert_equal('/b', fs.pwd)
          fs.chdir('d')
          assert_equal('/b/d', fs.pwd)
          fs.chdir('..')
          assert_equal('/b', fs.pwd)
          fs.chdir('..')
          assert_equal('/', fs.pwd)
        end

        def test_fs_entries
          fs = FileSystem.new do
            file 'a', nil
            dir 'b' do
              file 'c', nil
              file 'd', nil
            end
            file 'e', nil
            dir 'f' do
              file 'g', nil
              dir 'h' do
                file 'i', nil
              end
            end
          end
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('/').sort)
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('.').sort)
          assert_equal(['.', '..', 'a', 'b', 'e', 'f'], fs.entries('b/..').sort)
          assert_equal(['.', '..', 'c', 'd'], fs.entries('b').sort)
          assert_raises(Errno::ENOENT) do
            fs.entries('z')
          end
          assert_raises(Errno::ENOTDIR) do
            fs.entries('a')
          end
          fs.chdir('f')
          assert_equal(['.', '..', 'i'], fs.entries('h').sort)
        end

        class TestClass1
        end
        class TestClass2
        end
        def test_fs_require
          fs = FileSystem.new do
            file 'test_class1.rb', TestClass1
            dir 'dir' do
              file 'test_class2.rb', TestClass2
            end
          end
          c = []
          fs.object_space.each_object(Class) do |o|
            c << o
          end
          assert_equal([], c)

          assert_raises(LoadError) do
            fs.require('bogus')
          end

          assert(fs.require('test_class1.rb'))
          assert(!fs.require('test_class1.rb'))
          c = []
          fs.object_space.each_object(Class) do |o|
            c << o
          end
          assert_equal([TestClass1], c)

          fs.require('dir/test_class2')
          c = []
          fs.object_space.each_object(Class) do |o|
            c << o
          end
          assert_equal([TestClass1, TestClass2], c)

          c = []
          fs.object_space.each_object(Time) do |o|
            c << o
          end
          assert_equal([], c)
        end

        def setup
          @t1 = t1 = create_test(1)
          @t2 = t2 = create_test(2)
          @t3 = t3 = create_test(3)
          @t4 = t4 = create_test(4)
          @t5 = t5 = create_test(5)
          @t6 = t6 = create_test(6)
          fs = FileSystem.new do
            file 'test_1.rb', t1
            file 'test_2.rb', t2
            dir 'd1' do
              file 'test_3.rb', t3
            end
            file 't4.rb', t4
            dir 'd2' do
              file 'test_5', t5
              file 'test_6.rb', Time
            end
            file 't6.rb', t6
          end
          fs.require('t6')
          @c = Dir.new(fs, fs, fs.object_space, fs)
        end

        def create_test(name)
          t = Class.new(TestCase)
          t.class_eval <<-EOC
            self.test_order = :alphabetic
            def self.name
              "T\#{#{name}}"
            end
            def test_#{name}a
            end
            def test_#{name}b
            end
          EOC
          t
        end

        def test_simple_collect
          expected = TestSuite.new('d1')
          expected << (@t3.suite)
          assert_equal(expected, @c.collect('d1'))
        end

        def test_multilevel_collect
          expected = TestSuite.new('.')
          expected << @t1.suite << @t2.suite
          expected << (TestSuite.new('d1') << @t3.suite)
          assert_equal(expected, @c.collect)
        end

        def test_collect_file
          expected = TestSuite.new('test_1.rb')
          expected << @t1.suite
          assert_equal(expected, @c.collect('test_1.rb'))

          expected = TestSuite.new('t4.rb')
          expected << @t4.suite
          assert_equal(expected, @c.collect('t4.rb'))
        end

        def test_nil_pattern
          expected = TestSuite.new('d2')
          expected << @t5.suite
          @c.pattern.clear
          assert_equal(expected, @c.collect('d2'))
        end

        def test_filtering
          expected = TestSuite.new('.')
          expected << @t1.suite
          @c.filter = proc{|t| t.method_name == 'test_1a' || t.method_name == 'test_1b'}
          assert_equal(expected, @c.collect)
        end

        def test_collect_multi
          expected = TestSuite.new('[d1, d2]')
          expected << (TestSuite.new('d1') << @t3.suite)
          expected << (TestSuite.new('d2') << @t5.suite)
          @c.pattern.replace([/\btest_/])
          assert_equal(expected, @c.collect('d1', 'd2'))
        end
      end
    end
  end
end
test-unit-3.6.2/test/collector/test_objectspace.rb000066400000000000000000000057371456346657200223270ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'
require 'test/unit/collector/objectspace'

module Test
  module Unit
    module Collector
      class TC_ObjectSpace < TestCase
        def setup
          @tc1 = Class.new(TestCase) do
            self.test_order = :alphabetic
            def self.name
              "tc_1"
            end
            def test_1
            end
            def test_2
            end
          end

          @tc2 = Class.new(TestCase) do
            self.test_order = :alphabetic
            def self.name
              "tc_2"
            end
            def test_0
            end
          end

          @no_tc = Class.new do
            def test_4
            end
          end

          @object_space = {Class => [@tc1, @tc2, @no_tc], String => ['']}
          def @object_space.each_object(type)
            self[type].each{|item| yield(item) }
          end

          @c = ObjectSpace.new(@object_space)
        end

        def full_suite(name=ObjectSpace::NAME)
          expected = TestSuite.new(name)
          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1') << @tc1.new('test_2'))
          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
        end

        def empty_suite
          TestSuite.new(ObjectSpace::NAME)
        end

        def test_basic_collection
          assert_equal(full_suite("name"), @c.collect("name"))

          @c.filter = []
          assert_equal(full_suite("name"), @c.collect("name"))
        end

        def test_filtered_collection
          @c.filter = proc{false}
          assert_equal(empty_suite, @c.collect)

          @c.filter = proc{true}
          assert_equal(full_suite, @c.collect)

          @c.filter = proc{nil}
          assert_equal(full_suite, @c.collect)

          @c.filter = [proc{false}, proc{true}]
          assert_equal(empty_suite, @c.collect)

          @c.filter = [proc{true}, proc{false}]
          assert_equal(empty_suite, @c.collect)

          @c.filter = [proc{nil}, proc{false}]
          assert_equal(empty_suite, @c.collect)

          @c.filter = [proc{nil}, proc{true}]
          assert_equal(full_suite, @c.collect)

          expected = TestSuite.new(ObjectSpace::NAME)
          expected << (TestSuite.new(@tc1.name) << @tc1.new('test_1'))
          expected << (TestSuite.new(@tc2.name) << @tc2.new('test_0'))
          @c.filter = proc{|test| ['test_1', 'test_0'].include?(test.method_name)}
          assert_equal(expected, @c.collect)

          expected = TestSuite.new(ObjectSpace::NAME)
          TestSuite.new(@tc1.name) << @tc1.new('test_1')
          TestSuite.new(@tc2.name) << @tc2.new('test_0')
          @c.filter = [proc{|t| t.method_name == 'test_1' ? true : nil},
                       proc{|t| t.method_name == 'test_0' ? true : nil},
                       proc{false}]
          assert_equal(empty_suite, @c.collect)
        end
      end
    end
  end
end
test-unit-3.6.2/test/fixtures/000077500000000000000000000000001456346657200163305ustar00rootroot00000000000000test-unit-3.6.2/test/fixtures/header-label.csv000066400000000000000000000001031456346657200213440ustar00rootroot00000000000000label,expected,label
upper case,HELLO,HELLO
lower case,Hello,hello
test-unit-3.6.2/test/fixtures/header-label.tsv000066400000000000000000000001031456346657200213650ustar00rootroot00000000000000label	expected	label
upper case	HELLO	HELLO
lower case	Hello	hello
test-unit-3.6.2/test/fixtures/header.csv000066400000000000000000000001041456346657200202700ustar00rootroot00000000000000label,expected,target
empty string,true,""
plain string,false,hello
test-unit-3.6.2/test/fixtures/header.tsv000066400000000000000000000001041456346657200203110ustar00rootroot00000000000000label	expected	target
empty string	true	""
plain string	false	hello
test-unit-3.6.2/test/fixtures/no-header.csv000066400000000000000000000000561456346657200207100ustar00rootroot00000000000000empty string,true,""
plain string,false,hello
test-unit-3.6.2/test/fixtures/no-header.tsv000066400000000000000000000000561456346657200207310ustar00rootroot00000000000000empty string	true	""
plain string	false	hello
test-unit-3.6.2/test/fixtures/plus.csv000066400000000000000000000001171456346657200200270ustar00rootroot00000000000000label,expected,augend,addend
positive positive,4,3,1
positive negative,-1,1,-2
test-unit-3.6.2/test/run-test.rb000077500000000000000000000011541456346657200165710ustar00rootroot00000000000000#!/usr/bin/env ruby

$VERBOSE = true

$KCODE = "utf8" unless "".respond_to?(:encoding)

base_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
lib_dir = File.join(base_dir, "lib")
test_dir = File.join(base_dir, "test")

$LOAD_PATH.unshift(lib_dir)

require 'test/unit'

test_unit_notify_base_dir = File.join(base_dir, "..", "test-unit-notify")
test_unit_notify_base_dir = File.expand_path(test_unit_notify_base_dir)
if File.exist?(test_unit_notify_base_dir)
  $LOAD_PATH.unshift(File.join(test_unit_notify_base_dir, "lib"))
  require 'test/unit/notify'
end

exit Test::Unit::AutoRunner.run(true, test_dir)
test-unit-3.6.2/test/test-assertions.rb000066400000000000000000002555431456346657200201710ustar00rootroot00000000000000# -*- coding: utf-8 -*-
#
# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
#             Copyright (c) 2009-2014 Kouhei Sutou. All rights reserved.
# License:: Ruby license.

require 'test/unit'
require "testunit-test-util"

module Test
  module Unit
    module AssertionCheckable
      include TestUnitTestUtil

      private
      def check(value, message="")
        add_assertion
        raise AssertionFailedError.new(message) unless value
      end

      def check_assertions(expect_fail, options={})
        expected_message = options[:expected_message]
        actual_message_normalizer = options[:actual_message_normalizer]
        return_value_expected = options[:return_value_expected]
        @actual_assertion_count = 0
        failed = true
        actual_message = nil
        @catch_assertions = true
        return_value = nil
        begin
          return_value = yield
          failed = false
        rescue AssertionFailedError => error
          return_value = error
          actual_message = error.message
        end
        @catch_assertions = false

        if expect_fail
          message = "Should have failed, but didn't"
        else
          message = "Should not have failed, but did with message\n" +
            "<#{actual_message}>"
        end
        check(expect_fail == failed, message)

        message = "Should have made one assertion but made\n" +
          "<#{@actual_assertion_count}>"
        check(1 == @actual_assertion_count, message)

        if expect_fail
          if actual_message_normalizer
            actual_message = actual_message_normalizer.call(actual_message)
          end
          case expected_message
          when String
            check(expected_message == actual_message,
                  "Should have the correct message.\n" +
                  "<#{expected_message.inspect}> expected but was\n" +
                  "<#{actual_message.inspect}>")
          when Regexp
            check(expected_message =~ actual_message,
                  "The message should match correctly.\n" +
                  " expected to match\n" +
                  "<#{actual_message.inspect}>")
          else
            check(false,
                  "Incorrect expected message type in assert_nothing_failed")
          end
        else
          case return_value_expected
          when :dont_care
            # do nothing
          when true
            check(!return_value.nil?, "Should return a value")
          else
            check(return_value.nil?,
                  "Should not return a value but returned <#{return_value}>")
          end
        end

        return_value
      end

      def check_nothing_fails(return_value_expected=false, &proc)
        check_assertions(false,
                         {:expected_message => nil,
                          :return_value_expected => return_value_expected},
                         &proc)
      end

      def check_fail(expected_message, options={}, &proc)
        check_assertions(true,
                         options.merge(:expected_message => expected_message),
                         &proc)
      end

      def check_fail_exception(expected_message, options={}, &proc)
        normalizer = lambda do |actual_message|
          actual_message.gsub(/^(?:[a-zA-Z]:| )?[^:\n]+:\d+:.+\n/,
                              "")
        end
        check_assertions(true,
                         options.merge(:expected_message => expected_message,
                                       :actual_message_normalizer => normalizer),
                         &proc)
      end

      def inspect_tag(tag)
        tag.inspect
      end

      def add_failure(message, location=caller, options=nil)
        unless @catch_assertions
          super
        end
      end

      def add_assertion
        if @catch_assertions
          @actual_assertion_count += 1
        else
          super
        end
      end
    end

    class TestAssertions < TestCase
      include AssertionCheckable

      class TestAssertBlock < self
        def test_pass_without_message
          check_nothing_fails {
            assert_block {true}
          }
        end

        def test_pass_with_message
          check_nothing_fails {
            assert_block("successful assert_block") {true}
          }
        end

        def test_failure_without_message
          check_fail("assert_block failed.") {
            assert_block {false}
          }
        end

        def test_failure_with_message
          check_fail("failed assert_block") {
            assert_block("failed assert_block") {false}
          }
        end
      end

      class TestAssertEqual < self
        class TestSuccess < self
          def test_without_message
            check_nothing_fails {
              assert_equal("string1", "string1")
            }
          end

          def test_with_message
            check_nothing_fails {
              assert_equal("string1", "string1", "successful assert_equal")
            }
          end
        end

        class TestFailure < self
          def test_without_message
            message = <<-EOM.chomp
<"string1"> expected but was
<"string2">.

diff:
- string1
?       ^
+ string2
?       ^
EOM
            check_fail(message) {
              assert_equal("string1", "string2")
            }
          end

          def test_with_message
            message = <<-EOM.chomp
failed assert_equal.
<"string1"> expected but was
<"string2">.

diff:
- string1
?       ^
+ string2
?       ^
EOM
           check_fail(message) {
             assert_equal("string1", "string2", "failed assert_equal")
            }
          end

          def test_with_message_proc
            message = <<-EOM.chomp
failed assert_equal.
<"string1"> expected but was
<"string2">.

diff:
- string1
?       ^
+ string2
?       ^
EOM
           check_fail(message) do
              assert_equal("string1", "string2", lambda {"failed assert_equal"})
            end
          end
        end

        class TestSystemMessage < self
          def test_different_type
            message = <<-EOM.chomp
<"111111"> expected but was
<111111>.

diff:
- "111111"
? -      -
+ 111111
EOM
            check_fail(message) do
              assert_equal("111111", 111111)
            end
          end

          def test_long_line
            expected = ["0123456789",
                        "1123456789",
                        "2123456789",
                        "3123456789",
                        "4123456789",
                        "5123456789",
                        "6123456789",
                        "7123456789",
                        "8123456789"].join
            actual =   ["0000000000",
                        "1123456789",
                        "2123456789",
                        "3123456789",
                        "4123456789",
                        "5123456789",
                        "6123456789",
                        "7123456789",
                        "8123456789"].join
            message = <<-EOM.chomp
<"#{expected}"> expected but was
<"#{actual}">.

diff:
- #{expected}
?  ^^^^^^^^^
+ #{actual}
?  ^^^^^^^^^

folded diff:
- 012345678911234567892123456789312345678941234567895123456789612345678971234567
?  ^^^^^^^^^
+ 000000000011234567892123456789312345678941234567895123456789612345678971234567
?  ^^^^^^^^^
  898123456789
EOM
            check_fail(message) do
              assert_equal(expected, actual)
            end
          end

          def test_too_small_difference
            message = <<-EOM.chomp
<1> expected but was
<2>.
EOM
            check_fail(message) do
              assert_equal(1, 2)
            end
          end

          def test_same_inspected_objects
            same_inspected_class = Class.new do
              def inspect
                "inspected"
              end
            end
            object1 = same_inspected_class.new
            object2 = same_inspected_class.new
            message = <<-EOM.chomp
 expected but was
.
EOM
            check_fail(message) do
              assert_equal(object1, object2)
            end
          end

          def test_multi_lines_result
            message = <<-EOM.chomp
<#{AssertionMessage.convert("a\nb")}> expected but was
<#{AssertionMessage.convert("x")}>.

diff:
+ x
- a
- b
EOM
            check_fail(message) do
              assert_equal("a\nb", "x")
            end
          end

          def test_large_string
            message = <<-EOM.chomp
<#{AssertionMessage.convert("a\n" + "x" * 997)}> expected but was
<#{AssertionMessage.convert("x")}>.

diff:
+ x
- a
- #{"x" * 997}

folded diff:
+ x
- a
#{(["- " + ("x" * 78)] * 12).join("\n")}
- #{"x" * 61}
EOM
            check_fail(message) do
              assert_equal("a\n" + "x" * 997, "x")
            end

            message = <<-EOM.chomp
<#{AssertionMessage.convert("a\n" + "x" * 998)}> expected but was
<#{AssertionMessage.convert("x")}>.
EOM
            check_fail(message) do
              assert_equal("a\n" + "x" * 998, "x")
            end
          end

          def test_max_diff_target_string_size
            key = "TEST_UNIT_MAX_DIFF_TARGET_STRING_SIZE"
            before_value = ENV[key]
            ENV[key] = "100"
            begin
              message = <<-EOM.chomp
<#{AssertionMessage.convert("a\n" + "x" * 97)}> expected but was
<#{AssertionMessage.convert("x")}>.

diff:
+ x
- a
- #{"x" * 97}

folded diff:
+ x
- a
#{(["- " + ("x" * 78)]).join("\n")}
- #{"x" * 19}
EOM
              check_fail(message) do
                assert_equal("a\n" + "x" * 97, "x")
              end

              message = <<-EOM.chomp
<#{AssertionMessage.convert("a\n" + "x" * 98)}> expected but was
<#{AssertionMessage.convert("x")}>.
EOM
              check_fail(message) do
                assert_equal("a\n" + "x" * 98, "x")
              end
            ensure
              ENV[key] = before_value
            end
          end

          def test_different_encoding
            utf8_string = "こんにちは"
            unless utf8_string.respond_to?(:force_encoding)
              omit("encoding test is for Ruby >= 1.9")
            end
            ascii_8bit_string = utf8_string.dup.force_encoding("ascii-8bit")
            message = <<-EOM.chomp
<#{utf8_string.inspect}>("UTF-8") expected but was
<#{ascii_8bit_string.inspect}>("#{Encoding::ASCII_8BIT.name}").
EOM
            check_fail(message) do
              assert_equal(utf8_string, ascii_8bit_string)
            end
          end

          def test_different_hash
            designers = {
              "Ruby" => "Matz",
              "Lisp" => "John McCarthy",
            }
            categories = {
              "LL" => ["Ruby", "Python"],
              "Heavy" => ["C", "C++"],
            }
            message = <<-EOM.chomp
<{"Lisp"=>"John McCarthy", "Ruby"=>"Matz"}> expected but was
<{"Heavy"=>["C", "C++"], "LL"=>["Ruby", "Python"]}>.
EOM
            check_fail(message) do
              assert_equal(designers, categories)
            end
          end

          def test_recursive_hash
            alice = {"name" => "Alice"}
            bob = {"name" => "Bob"}
            alice["followers"] = [bob]
            bob["followers"] = [alice]
            message = <<-EOM.chomp
<{"followers"=>[{"followers"=>[{...}], "name"=>"Bob"}], "name"=>"Alice"}> expected but was
<{"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}>.

diff:
- {"followers"=>[{"followers"=>[{...}], "name"=>"Bob"}], "name"=>"Alice"}
?                                       -----------------
+ {"followers"=>[{"followers"=>[{...}], "name"=>"Alice"}], "name"=>"Bob"}
?                                                       +++++++++++++++++
EOM
            check_fail(message) do
              assert_equal(alice, bob)
            end
          end

          def test_numeric
            numeric_family_class = Class.new(Numeric) do
              def inspect
                "inspect is called"
              end

              def to_s
                "to_s is called"
              end
            end
            numeric = numeric_family_class.new

            message = <<-MESSAGE.chomp
 expected but was
<"must be failed">.
            MESSAGE
            check_fail(message) do
              assert_equal(numeric, "must be failed")
            end
          end
        end
      end

      def test_assert_raise_success
        return_value = nil
        check_nothing_fails(true) do
          return_value = assert_raise(RuntimeError) do
            raise "Error"
          end
        end
        check(return_value.kind_of?(Exception),
              "Should have returned the exception " +
              "from a successful assert_raise")
        check(return_value.message == "Error",
              "Should have returned the correct exception " +
              "from a successful assert_raise")

        check_nothing_fails(true) do
          assert_raise(ArgumentError, "successful assert_raise") do
            raise ArgumentError.new("Error")
          end
        end

        check_nothing_fails(true) do
          assert_raise(RuntimeError) do
            raise "Error"
          end
        end

        check_nothing_fails(true) do
          assert_raise(RuntimeError, "successful assert_raise") do
            raise "Error"
          end
        end

        check_nothing_fails(true) do
          assert_raise do
            raise Exception, "Any exception"
          end
        end
      end

      def test_assert_raise_fail
        check_fail(" exception was expected but none was thrown.") do
          assert_raise(RuntimeError) do
            1 + 1
          end
        end

        message = <<-EOM.chomp
failed assert_raise.
 exception expected but was
)
>.
EOM
        check_fail_exception(message) do
          assert_raise(ArgumentError, "failed assert_raise") do
            raise "Error"
          end
        end

        message = <<-EOM
 must be a subclass of Exception, an object of Exception subclasses or a Module.
EOM
        check_fail(message.chomp) do
          assert_nothing_raised(Object) do
            1 + 1
          end
        end
      end

      def test_assert_raise_module
        exceptions = [ArgumentError, TypeError]
        modules = [Math, Comparable]
        rescues = exceptions + modules

        exceptions.each do |exc|
          return_value = nil
          check_nothing_fails(true) do
            return_value = assert_raise(*rescues) do
              raise exc, "Error"
            end
          end
          check(return_value.instance_of?(exc),
                "Should have returned #{exc} but was #{return_value.class}")
          check(return_value.message == "Error",
                "Should have returned the correct exception " +
                "from a successful assert_raise")
        end

        modules.each do |mod|
          return_value = nil
          check_nothing_fails(true) do
            return_value = assert_raise(*rescues) do
              raise Exception.new("Error").extend(mod)
            end
          end
          check(mod === return_value,
                "Should have returned #{mod}")
          check(return_value.message == "Error",
                "Should have returned the correct exception " +
                "from a successful assert_raise")
        end

        check_fail("<[ArgumentError, TypeError, Math, Comparable]> exception " +
                    "was expected but none was thrown.") do
          assert_raise(*rescues) do
            1 + 1
          end
        end

        message = <<-EOM.chomp
failed assert_raise.
<[ArgumentError, TypeError]> exception expected but was
)
>.
EOM
        check_fail_exception(message) do
          assert_raise(ArgumentError, TypeError, "failed assert_raise") do
            raise "Error"
          end
        end
      end

      def test_assert_raise_instance
        return_value = nil
        check_nothing_fails(true) do
          return_value = assert_raise(RuntimeError.new("Error")) do
            raise "Error"
          end
        end
        check(return_value.kind_of?(Exception),
              "Should have returned the exception " +
              "from a successful assert_raise")
        check(return_value.message == "Error",
              "Should have returned the correct exception " +
              "from a successful assert_raise")

        message = <<-EOM.chomp
)> exception expected but was
)
>.
EOM
        check_fail_exception(message) do
          return_value = assert_raise(RuntimeError.new("XXX")) do
            raise "Error"
          end
        end

        different_error_class = Class.new(StandardError)
        message = <<-EOM.chomp
<#{different_error_class.inspect}()> exception expected but was
)
>.
EOM
        check_fail_exception(message) do
          assert_raise(different_error_class.new("Error")) do
            raise "Error"
          end
        end

        different_error = different_error_class.new("Error")
        def different_error.inspect
          "DifferentError: \"Error\""
        end
        message = <<-EOM.chomp
 exception expected but was
)
>.
EOM
        check_fail_exception(message) do
          assert_raise(different_error) do
            raise "Error"
          end
        end

        check_nothing_fails(true) do
          assert_raise(different_error_class.new("Error"),
                       RuntimeError.new("Error"),
                       RuntimeError.new("XXX")) do
            raise "Error"
          end
        end
      end

      def test_assert_raise_jruby
        jruby_only_test

        exception = Java::JavaLang::StringIndexOutOfBoundsException

        return_value = nil
        check_nothing_fails(true) do
          return_value = assert_raise(exception) do
            Java::JavaLang::String.new("abc").char_at(4)
          end
        end
        check(return_value.instance_of?(exception),
              "Should have returned #{exception} but was #{return_value.class}")
      end

      def test_assert_instance_of
        check_nothing_fails {
          assert_instance_of(String, "string")
        }
        check_nothing_fails {
          assert_instance_of(String, "string", "successful assert_instance_of")
        }
        check_nothing_fails {
          assert_instance_of(String, "string", "successful assert_instance_of")
        }
        check_fail(%Q{<"string"> was expected to be instance_of?\n but was\n.}) {
          assert_instance_of(Hash, "string")
        }
        check_fail(%Q{failed assert_instance_of.\n<"string"> was expected to be instance_of?\n but was\n.}) {
          assert_instance_of(Hash, "string", "failed assert_instance_of")
        }

        check_nothing_fails do
          assert_instance_of([Class, NilClass], Array)
        end
        check_fail(%Q{<"string"> was expected to be instance_of?\n[, ] but was\n.}) do
          assert_instance_of([Class, NilClass], "string")
        end
        check_fail(%Q{ was expected to be instance_of?\n[, ] but was\n.}) do
          assert_instance_of([Module, NilClass], Array)
        end
      end

      def test_assert_not_instance_of
        check_nothing_fails {
          assert_not_instance_of(NilClass, "string")
        }
        check_nothing_fails {
          assert_not_instance_of(NilClass, "string", "successful assert_instance_of")
        }
        check_fail(%Q{<"string"> was expected to not be instance_of?\n but was.}) {
          assert_not_instance_of(String, "string")
        }
        check_fail(%Q{failed assert.\n<"string"> was expected to not be instance_of?\n but was.}) {
          assert_not_instance_of(String, "string", "failed assert")
        }

        check_nothing_fails do
          assert_not_instance_of([Module, NilClass], Array)
        end
        check_fail(%Q{ was expected to not be instance_of?\n[, ] but was.}) do
          assert_not_instance_of([Class, NilClass], Array)
        end
        check_fail(%Q{<"str"> was expected to not be instance_of?\n[, ] but was.}) do
          assert_not_instance_of([Numeric, String], 'str')
        end
      end

      def test_assert_nil
        check_nothing_fails {
          assert_nil(nil)
        }
        check_nothing_fails {
          assert_nil(nil, "successful assert_nil")
        }
        check_nothing_fails {
          assert_nil(nil, "successful assert_nil")
        }
        check_fail(%Q{<"string"> was expected to be nil.}) {
          assert_nil("string")
        }
        check_fail(%Q{failed assert_nil.\n<"string"> was expected to be nil.}) {
          assert_nil("string", "failed assert_nil")
        }
      end

      def test_assert_not_nil
        check_nothing_fails{assert_not_nil(false)}
        check_nothing_fails{assert_not_nil(false, "message")}
        check_fail(" was expected to not be nil."){assert_not_nil(nil)}
        check_fail("message.\n was expected to not be nil.") {assert_not_nil(nil, "message")}
      end

      def test_assert_kind_of
        check_nothing_fails {
          assert_kind_of(Module, Array)
        }
        check_nothing_fails {
          assert_kind_of(Object, "string", "successful assert_kind_of")
        }
        check_nothing_fails {
          assert_kind_of(String, "string", "successful assert_kind_of")
        }
        check_nothing_fails {
          assert_kind_of(Comparable, 1)
        }
        check_fail(%Q{<"string"> was expected to be kind_of?\n but was\n.}) {
          assert_kind_of(Class, "string")
        }
        check_fail(%Q{failed assert_kind_of.\n<"string"> was expected to be kind_of?\n but was\n.}) {
          assert_kind_of(Class, "string", "failed assert_kind_of")
        }

        check_nothing_fails do
          assert_kind_of([Class, NilClass], Array)
        end
        check_fail(%Q{<"string"> was expected to be kind_of?\n[, ] but was\n.}) do
          assert_kind_of([Class, NilClass], "string")
        end
      end

      def test_assert_not_kind_of
        check_nothing_fails {
          assert_not_kind_of(Class, 42)
        }
        check_nothing_fails {
          assert_not_kind_of(Symbol, "string", "successful assert_not_kind_of")
        }
        check_nothing_fails {
          assert_not_kind_of(Integer, 1.1)
        }
        check_fail(%Q{<1> was expected to not be kind_of?\n but was.}) {
          assert_not_kind_of(Integer, 1)
        }
        check_fail(%Q{failed assert_not_kind_of.\n<"string"> was expected to not be kind_of?\n but was.}) {
          assert_not_kind_of(String, "string", "failed assert_not_kind_of")
        }

        check_nothing_fails do
          assert_not_kind_of([String, NilClass], 100)
        end
        check_fail(%Q{ was expected to not be kind_of?\n[, ] but was.}) do
          assert_not_kind_of([Class, NilClass], Array)
        end
      end

      def test_assert_match
        check_nothing_fails {
          assert_match(/strin./, "string")
        }
        check_nothing_fails {
          assert_match("strin", "string")
        }
        check_nothing_fails {
          assert_match(/strin./, "string", "successful assert_match")
        }
        check_nothing_fails {
          assert_match(/strin./, "string", "successful assert_match")
        }
        check_fail(%Q{ was expected to be =~\n<"string">.}) {
          assert_match(/slin./, "string")
        }
        check_fail(%Q{ was expected to be =~\n<"string">.}) {
          assert_match("strin.", "string")
        }
        check_fail(%Q{failed assert_match.\n was expected to be =~\n<"string">.}) {
          assert_match(/slin./, "string", "failed assert_match")
        }
      end

      def test_assert_same
        thing = "thing"
        check_nothing_fails {
          assert_same(thing, thing)
        }
        check_nothing_fails {
          assert_same(thing, thing, "successful assert_same")
        }
        check_nothing_fails {
          assert_same(thing, thing, "successful assert_same")
        }
        thing2 = thing.dup
        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> was expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
          assert_same(thing, thing2)
        }
        check_fail(%Q{failed assert_same.\n<"thing">\nwith id <#{thing.__id__}> was expected to be equal? to\n<"thing">\nwith id <#{thing2.__id__}>.}) {
          assert_same(thing, thing2, "failed assert_same")
        }
      end

      def test_assert_equal
        return_true_class = Class.new do
          def ==(*args)
            true
          end
        end

        thing = return_true_class.new

        check_nothing_fails do
          assert_equal(thing, true)
        end

        check_fail(%Q{ expected but was\n<#{thing.inspect}>.}) {
          assert_equal(true, thing)
        }
      end

      def test_assert_nothing_raised
        check_nothing_fails(:dont_care) {
          assert_nothing_raised {
            1 + 1
          }
        }
        check_nothing_fails(:dont_care) {
          assert_nothing_raised("successful assert_nothing_raised") {
            1 + 1
          }
        }
        check_nothing_fails(:dont_care) {
          assert_nothing_raised("successful assert_nothing_raised") {
            1 + 1
          }
        }
        check_nothing_fails(:dont_care) {
          begin
            assert_nothing_raised(RuntimeError, StandardError, Comparable, "successful assert_nothing_raised") {
              raise ZeroDivisionError.new("ArgumentError")
            }
          rescue ZeroDivisionError
          end
        }
        expected_message =
          " must be a subclass of Exception, " +
          "an object of Exception subclasses or a Module."
        check_fail(expected_message) {
          assert_nothing_raised(Object) {
            1 + 1
          }
        }
        expected_message = <<-EOM.chomp
Exception raised:
RuntimeError()

EOM
        check_fail_exception(expected_message) {
          assert_nothing_raised {
            raise "Error"
          }
        }
        expected_message = <<-EOM.chomp
failed assert_nothing_raised.
Exception raised:
RuntimeError()

EOM
        check_fail_exception(expected_message) {
          assert_nothing_raised("failed assert_nothing_raised") {
            raise "Error"
          }
        }
        expected_message = <<-EOM.chomp
Exception raised:
RuntimeError()

EOM
        check_fail_exception(expected_message) {
          assert_nothing_raised(StandardError, RuntimeError) {
            raise "Error"
          }
        }
        check_fail("Failure.") do
          assert_nothing_raised do
            flunk("Failure")
          end
        end
      end

      def test_flunk
        check_fail("Flunked.") {
          flunk
        }
        check_fail("flunk message.") {
          flunk("flunk message")
        }
      end

      def test_assert_not_same
        thing = "thing"
        thing2 = thing.dup
        check_nothing_fails {
          assert_not_same(thing, thing2)
        }
        check_nothing_fails {
          assert_not_same(thing, thing2, "message")
        }
        check_fail(%Q{<"thing">\nwith id <#{thing.__id__}> was expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
          assert_not_same(thing, thing)
        }
        check_fail(%Q{message.\n<"thing">\nwith id <#{thing.__id__}> was expected to not be equal? to\n<"thing">\nwith id <#{thing.__id__}>.}) {
          assert_not_same(thing, thing, "message")
        }
      end

      def test_assert_not_equal
        check_nothing_fails {
          assert_not_equal("string1", "string2")
        }
        check_nothing_fails {
          assert_not_equal("string1", "string2", "message")
        }
        check_fail(%Q{<"string"> was expected to be != to\n<"string">.}) {
          assert_not_equal("string", "string")
        }
        check_fail(%Q{message.\n<"string"> was expected to be != to\n<"string">.}) {
          assert_not_equal("string", "string", "message")
        }
      end

      def test_assert_not_match_pass
        check_nothing_fails do
          assert_not_match(/sling/, "string")
        end
      end

      def test_assert_not_match_pass_with_message
        check_nothing_fails do
          assert_not_match(/sling/, "string", "message")
        end
      end

      def test_assert_not_match_fail_match
        check_fail(" was expected to not match\n" +
                    "<\"string\">.") do
          assert_not_match(/string/, "string")
        end
      end

      def test_assert_not_match_fail_match_string
        check_fail(" was expected to not match\n" +
                    "<\"asdf\">.") do
          assert_not_match("asdf", "asdf")
        end
      end

      def test_assert_not_match_fail_match_with_message
        check_fail("message.\n" +
                    " was expected to not match\n" +
                    "<\"string\">.") do
          assert_not_match(/string/, "string", "message")
        end
      end

      def test_assert_no_match
        check_nothing_fails{assert_no_match(/sling/, "string")}
        check_nothing_fails{assert_no_match(/sling/, "string", "message")}
        check_fail(%Q{The first argument to assert_no_match should be a Regexp.\n<"asdf"> was expected to be instance_of?\n but was\n.}) do
          assert_no_match("asdf", "asdf")
        end
        check_fail(%Q{ was expected to not match\n<"string">.}) do
          assert_no_match(/string/, "string")
        end
        check_fail(%Q{message.\n was expected to not match\n<"string">.}) do
          assert_no_match(/string/, "string", "message")
        end
      end

      def test_assert_throw
        check_nothing_fails do
          assert_throw(:thing, "message") do
            throw :thing
          end
        end

        tag = :thing2
        check_fail("message.\n" +
                    "<:thing> was expected to be thrown but\n" +
                    "<#{inspect_tag(tag)}> was thrown.") do
          assert_throw(:thing, "message") do
            throw :thing2
          end
        end
        check_fail("message.\n" +
                    "<:thing> should have been thrown.") do
          assert_throw(:thing, "message") do
            1 + 1
          end
        end
      end

      def test_assert_nothing_thrown
        check_nothing_fails do
          assert_nothing_thrown("message") do
            1 + 1
          end
        end

        tag = :thing
        inspected = inspect_tag(tag)
        check_fail("message.\n" +
                    "<#{inspected}> was thrown when nothing was expected.") do
          assert_nothing_thrown("message") do
            throw tag
          end
        end
      end

      def test_assert_operator
        check_nothing_fails {
          assert_operator("thing", :==, "thing", "message")
        }
        check_fail(%Q{<0.15>\ngiven as the operator for #assert_operator must be a Symbol or #respond_to?(:to_str).}) do
          assert_operator("thing", 0.15, "thing")
        end
        check_fail(%Q{message.\n<"thing1"> was expected to be\n==\n<"thing2">.}) {
          assert_operator("thing1", :==, "thing2", "message")
        }
      end

      def test_assert_not_operator
        check_nothing_fails {
          assert_not_operator("thing", :==, "Thing", "message")
        }
        check_fail(%Q{<42>\ngiven as the operator for #assert_not_operator must be a Symbol or #respond_to?(:to_str).}) do
          assert_not_operator("thing", 42, "message")
        end
        check_fail(%Q{message.\n<0> was expected to not be\n==\n<0.0>.}) {
          assert_not_operator(0, :==, 0.0, "message")
        }
      end

      def test_assert_respond_to
        check_nothing_fails {
          assert_respond_to("thing", :to_s, "message")
        }
        check_nothing_fails {
          assert_respond_to("thing", "to_s", "message")
        }
        check_fail("<0.15>.kind_of?(Symbol) or\n" +
                    "<0.15>.respond_to?(:to_str) expected") {
          assert_respond_to("thing", 0.15)
        }
        check_fail("message.\n" +
                    "<:symbol>.respond_to?(:nonexistence) expected\n" +
                    "(Class: )") {
          assert_respond_to(:symbol, :nonexistence, "message")
        }
      end

      def test_assert_not_respond_to_pass_symbol
        check_nothing_fails do
          assert_not_respond_to("thing", :nonexistent, "message")
        end
      end

      def test_assert_not_respond_to_pass_string
        check_nothing_fails do
          assert_not_respond_to("thing", :nonexistent, "message")
        end
      end

      def test_assert_not_respond_to_fail_number
        check_fail("<0.15>.kind_of?(Symbol) or\n" +
                    "<0.15>.respond_to?(:to_str) expected") do
          assert_not_respond_to("thing", 0.15)
        end
      end

      def test_assert_send
        object = Object.new
        class << object
          private
          def return_argument(argument, bogus)
            return argument
          end
        end
        check_nothing_fails do
          assert_send([object, :return_argument, true, "bogus"], "message")
        end

        inspected_object = AssertionMessage.convert(object)
        expected_message = <<-EOM
message.
<#{inspected_object}> was expected to respond to
 with a true value but was
.
EOM
        check_fail(expected_message.chomp) do
          assert_send([object, :return_argument, false, "bogus"], "message")
        end
      end

      def test_condition_invariant
        object = Object.new
        def object.inspect
          @changed = true
        end
        def object.==(other)
          @changed ||= false
          return (!@changed)
        end
        check_nothing_fails do
          assert_equal(object, object, "message")
        end
      end

      def test_assert_boolean
        check_nothing_fails do
          assert_boolean(true)
        end
        check_nothing_fails do
          assert_boolean(false)
        end

        check_fail(" or  expected but was\n<1>") do
          assert_boolean(1)
        end

        check_fail(" or  expected but was\n") do
          assert_boolean(nil)
        end

        check_fail("message.\n or  expected but was\n<\"XXX\">") do
          assert_boolean("XXX", "message")
        end

        return_true_class = Class.new do
          def ==(*args)
            true
          end
        end

        thing = return_true_class.new

        check_fail(%Q{ or  expected but was\n<#{thing.inspect}>}) {
          assert_boolean(thing)
        }
      end

      def test_assert_true
        check_nothing_fails do
          assert_true(true)
        end

        check_fail(" expected but was\n") do
          assert_true(false)
        end

        check_fail(" expected but was\n<1>") do
          assert_true(1)
        end

        exception = check_fail("message.\n expected but was\n") do
          assert_true(nil, "message")
        end
        assert_equal("message", exception.user_message)

        return_true_class = Class.new do
          def ==(*args)
            true
          end
        end

        thing = return_true_class.new

        check_fail(%Q{ expected but was\n<#{thing.inspect}>}) {
          assert_true(thing)
        }
      end

      def test_assert_false
        check_nothing_fails do
          assert_false(false)
        end

        check_fail(" expected but was\n") do
          assert_false(true)
        end

        check_fail(" expected but was\n") do
          assert_false(nil)
        end

        check_fail("message.\n expected but was\n<:false>") do
          assert_false(:false, "message")
        end

        return_true_class = Class.new do
          def ==(*args)
            true
          end
        end

        thing = return_true_class.new

        check_fail(%Q{ expected but was\n<#{thing.inspect}>}) {
          assert_false(thing)
        }
      end

      def test_assert_compare
        check_nothing_fails do
          assert_compare(1.4, "<", 10.0)
        end

        check_nothing_fails do
          assert_compare(2, "<=", 2)
        end

        check_nothing_fails do
          assert_compare(14, ">=", 10.0)
        end

        check_nothing_fails do
          assert_compare(14, ">", 13.9)
        end

        expected_message = <<-EOM
<15> < <10> should be true
<15> was expected to be less than
<10>.
EOM
        check_fail(expected_message.chomp) do
          assert_compare(15, "<", 10)
        end

        expected_message = <<-EOM
<15> <= <10> should be true
<15> was expected to be less than or equal to
<10>.
EOM
        check_fail(expected_message.chomp) do
          assert_compare(15, "<=", 10)
        end

        expected_message = <<-EOM
<10> > <15> should be true
<10> was expected to be greater than
<15>.
EOM
        check_fail(expected_message.chomp) do
          assert_compare(10, ">", 15)
        end

        expected_message = <<-EOM
<10> >= <15> should be true
<10> was expected to be greater than or equal to
<15>.
EOM
        check_fail(expected_message.chomp) do
          assert_compare(10, ">=", 15)
        end
      end

      def test_assert_fail_assertion
        check_nothing_fails do
          assert_fail_assertion do
            flunk
          end
        end

        check_fail("Failed assertion was expected.") do
          assert_fail_assertion do
          end
        end
      end

      def test_assert_raise_message
        check_nothing_fails do
          assert_raise_message("Raise!") do
            raise "Raise!"
          end
        end

        check_nothing_fails do
          assert_raise_message("Raise!") do
            raise Exception, "Raise!"
          end
        end

        check_nothing_fails do
          assert_raise_message(/raise/i) do
            raise "Raise!"
          end
        end

        expected_message = <<-EOM
<"Expected message"> exception message expected but was
<"Actual message">.
EOM
        check_fail(expected_message.chomp) do
          assert_raise_message("Expected message") do
            raise "Actual message"
          end
        end

        expected_message = <<-EOM
<"Expected message"> exception message was expected but none was thrown.
EOM
        check_fail(expected_message.chomp) do
          assert_raise_message("Expected message") do
          end
        end
      end

      def test_assert_raise_kind_of
        check_nothing_fails(true) do
          assert_raise_kind_of(SystemCallError) do
            raise Errno::EACCES
          end
        end

        expected_message = <<-EOM.chomp
 family exception expected but was
)
>.
EOM
        check_fail_exception(expected_message) do
          assert_raise_kind_of(SystemCallError) do
            raise RuntimeError, "XXX"
          end
        end
      end

      def test_assert_const_defined
        check_nothing_fails do
          assert_const_defined(Test, :Unit)
        end

        check_nothing_fails do
          assert_const_defined(Test, "Unit")
        end

        check_fail(".const_defined?(<:Nonexistence>) expected.") do
          assert_const_defined(Test, :Nonexistence)
        end
      end

      def test_assert_not_const_defined
        check_nothing_fails do
          assert_not_const_defined(Test, :Nonexistence)
        end

        check_fail("!.const_defined?(<:Unit>) expected.") do
          assert_not_const_defined(Test, :Unit)
        end

        check_fail("!.const_defined?(<\"Unit\">) expected.") do
          assert_not_const_defined(Test, "Unit")
        end
      end

      def test_assert_predicate
        check_nothing_fails do
          assert_predicate([], :empty?)
        end

        check_fail("<[1]>.empty? is true value expected but was\n") do
          assert_predicate([1], :empty?)
        end

        check_fail("<[1]>.respond_to?(:nonexistent?) expected\n" +
                    "(Class: )") do
          assert_predicate([1], :nonexistent?)
        end
      end

      def test_assert_not_predicate
        check_nothing_fails do
          assert_not_predicate([1], :empty?)
        end

        check_fail("<[]>.empty? is false value expected but was\n") do
          assert_not_predicate([], :empty?)
        end

        check_fail("<[]>.respond_to?(:nonexistent?) expected\n" +
                    "(Class: )") do
          assert_not_predicate([], :nonexistent?)
        end
      end

      def test_assert_alias_method
        object = Object.new
        class << object
          def original_method
          end
          alias_method :alias_method, :original_method

          def other
          end
        end

        check_nothing_fails do
          assert_alias_method(object, :alias_method, :original_method)
        end

        check_nothing_fails do
          assert_alias_method(object, :original_method, :alias_method)
        end

        check_fail("<#{object.method(:other).inspect}> is alias of\n" +
                    "<#{object.method(:original_method).inspect}> expected") do
          assert_alias_method(object, :other, :original_method)
        end

        inspected_object = AssertionMessage.convert(object)
        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
                    "(Class: )") do
          assert_alias_method(object, :nonexistent, :original_method)
        end

        check_fail("<#{inspected_object}>.nonexistent doesn't exist\n" +
                    "(Class: )") do
          assert_alias_method(object, :alias_method, :nonexistent)
        end
      end

      def test_assert_path_exist
        check_nothing_fails do
          assert_path_exist(__FILE__)
        end

        nonexistent_file = __FILE__ + ".nonexistent"
        check_fail("<#{nonexistent_file.inspect}> was expected to exist") do
          assert_path_exist(nonexistent_file)
        end
      end

      def test_assert_path_not_exist
        nonexistent_file = __FILE__ + ".nonexistent"
        check_nothing_fails do
          assert_path_not_exist(nonexistent_file)
        end

        check_fail("<#{__FILE__.inspect}> was expected to not exist") do
          assert_path_not_exist(__FILE__)
        end
      end
    end

    class TestAssert < TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert(true)
        end
      end

      def test_pass_neither_false_or_nil
        check_nothing_fails do
          assert("a")
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert(true, "successful assert")
        end
      end

      def test_pass_block
        check_nothing_fails do
          assert do
            true
          end
        end
      end

      def test_fail_nil
        check_fail(" is not true.") do
          assert(nil)
        end
      end

      def test_fail_false
        check_fail(" is not true.") do
          assert(false)
        end
      end

      def test_fail_false_with_message
        check_fail("failed assert.\n" +
                    " is not true.") do
          assert(false, "failed assert")
        end
      end

      def test_fail_with_assertion_message
        check_fail("user message.\n" +
                    "placeholder <:in> message") do
          assert(false, build_message("user message",
                                      "placeholder  message",
                                      :in))
        end
      end

      def test_fail_block
        check_fail(//) do
          assert do
            0.odd?
          end
        end
      end

      def test_error_invalid_message_true
        check_fail("assertion message must be String, Proc or " +
                    "Test::Unit::Assertions::AssertionMessage: " +
                    "()") do
          begin
            assert(true, true)
          rescue ArgumentError
            raise AssertionFailedError, $!.message
          end
        end
      end

      def test_error_wrong_number_of_arguments
        check_fail("wrong number of arguments (0 for 1..2)") do
          begin
            assert
          rescue ArgumentError
            raise AssertionFailedError, $!.message
          end
        end
      end

      class TestBlock < self
        def test_with_message
          if defined?(PowerAssert)
            system_message = <<-MESSAGE.chomp
              1.to_s == "2"
                |    |
                |    false
                "1"
MESSAGE
          else
            system_message = " is not true."
          end
          check_fail("user message.\n#{system_message}") do
            assert("user message") do
              1.to_s == "2"
            end
          end
        end
      end
    end

    class TestRefute < TestCase
      include AssertionCheckable

      class TestPass < self
        def test_nil
          check_nothing_fails do
            refute(nil)
          end
        end

        def test_false
          check_nothing_fails do
            refute(false)
          end
        end

        def test_with_message
          check_nothing_fails do
            refute(nil, "successful refute")
          end
        end
      end

      class TestFailure < self
        def test_true
          check_fail(" is neither nil or false.") do
            refute(true)
          end
        end

        def test_with_message
          check_fail("failed refute.\n" +
                       " is neither nil or false.") do
            refute(true, "failed refute")
          end
        end

        def test_fail_with_assertion_message
          check_fail("user message.\n" +
                       "placeholder <:in> message") do
            refute(true, build_message("user message",
                                       "placeholder  message",
                                       :in))
          end
        end

        def test_error_invalid_message_true
          check_fail("assertion message must be String, Proc or " +
                       "Test::Unit::Assertions::AssertionMessage: " +
                "()") do
            begin
              refute(true, false)
            rescue ArgumentError
              raise AssertionFailedError, $!.message
            end
          end
        end
      end
    end

    class TestAssertRaiseWithMessage < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass_string
        check_nothing_fails(true) do
          assert_raise_with_message(RuntimeError, "Boom!!!") do
            raise "Boom!!!"
          end
        end
      end

      def test_pass_regexp
        check_nothing_fails(true) do
          assert_raise_with_message(RuntimeError, /!!!/) do
            raise "Boom!!!"
          end
        end
      end

      def test_pass_message
        check_nothing_fails(true) do
          assert_raise_with_message(RuntimeError, "Boom!!!", "message") do
            raise "Boom!!!"
          end
        end
      end

      def test_fail_unmatch_class
        expected_message = <<-MESSAGE.chomp
message.
(<"Boom!!!">) exception expected but was
(<"Boom!!!">).

diff:
- [LoadError, "Boom!!!"]
?  ^^^^
+ [RuntimeError, "Boom!!!"]
?  ^^^^^^^
        MESSAGE
        check_fail(expected_message) do
          assert_raise_with_message(LoadError, "Boom!!!", "message") do
            raise "Boom!!!"
          end
        end
      end

      def test_fail_unmatch_message
        expected_message = <<-MESSAGE.chomp
message.
() exception expected but was
(<"Boom!!!">).
        MESSAGE
        check_fail(expected_message) do
          assert_raise_with_message(RuntimeError, /Hello/, "message") do
            raise "Boom!!!"
          end
        end
      end
    end

    class TestAssertInDelta < TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_in_delta(1.4, 1.4, 0)
        end
      end

      def test_pass_without_delta
        check_nothing_fails do
          assert_in_delta(1.401, 1.402)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_in_delta(0.5, 0.4, 0.1, "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            0.2
          end
          assert_in_delta(0.1, float_thing, 0.1)
        end
      end

      def test_pass_string_expected
        check_nothing_fails do
          assert_in_delta("0.5", 0.4, 0.1)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.5> -/+ <0.05> was expected to include\n" +
                    "<0.4>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<<0.4> < <0.5>-<0.05>[0.45] <= <0.5>+<0.05>[0.55]>") do
          assert_in_delta(0.5, 0.4, 0.05, "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_in_delta(object, 0.4, 0.1)
        end
      end

      def test_fail_because_negaitve_delta
        check_fail("The delta should not be negative.\n" +
                    "<-0.1> was expected to be\n>=\n<0.0>.") do
          assert_in_delta(0.5, 0.4, -0.1, "message")
        end
      end

      def test_fail_without_delta
        check_fail("<1.402> -/+ <0.001> was expected to include\n" +
                    "<1.404>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<1.402>-<0.001>[#{1.402 - 0.001}] <= " +
                    "<1.402>+<0.001>[#{1.402 + 0.001}] < " +
                    "<1.404>" +
                    ">") do
          assert_in_delta(1.402, 1.404)
        end
      end
    end

    class TestAssertInDeltaBigDecimal < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_in_delta(BigDecimal("1.40000000000000000001"),
                          BigDecimal("1.40000000000000000001"),
                          0)
        end
      end

      def test_pass_without_delta
        check_nothing_fails do
          assert_in_delta(BigDecimal("1.40000000000000000001"),
                          BigDecimal("1.40000000000000000002"))
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_in_delta(BigDecimal("1.40000000000000000001"),
                          BigDecimal("1.50000000000000000001"),
                          BigDecimal("0.1"),
                          "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            0.2
          end
          assert_in_delta(BigDecimal("0.1"),
                          float_thing,
                          BigDecimal("0.1"))
        end
      end

      def test_pass_string_expected
        check_nothing_fails do
          assert_in_delta("0.5",
                          BigDecimal("0.4"),
                          BigDecimal("0.1"))
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.50000000000000000001e0> -/+ <0.5e-1> was expected to include\n" +
                    "<0.40000000000000000001e0>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.40000000000000000001e0> < " +
                    "<0.50000000000000000001e0>-<0.5e-1>[0.45000000000000000001e0] <= " +
                    "<0.50000000000000000001e0>+<0.5e-1>[0.55000000000000000001e0]" +
                    ">") do
          assert_in_delta(BigDecimal("0.50000000000000000001"),
                          BigDecimal("0.40000000000000000001"),
                          BigDecimal("0.05"),
                          "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_in_delta(object,
                          BigDecimal("0.4"),
                          BigDecimal("0.1"))
        end
      end

      def test_fail_with_float_like_object
        object = Object.new
        def object.to_f
          0.4
        end
        inspected_object = AssertionMessage.convert(object)
        check_fail("<0.10000000000000000001e0> -/+ <0.1e0> was expected to include\n" +
                    "<#{inspected_object}>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.10000000000000000001e0>-<0.1e0>[0.0] <= " +
                    "<0.10000000000000000001e0>+<0.1e0>[0.2] < " +
                    "<#{inspected_object}>" +
                    ">") do
          assert_in_delta(BigDecimal("0.10000000000000000001"),
                          object,
                          BigDecimal("0.1"))
        end
      end

      def test_fail_because_negaitve_delta
        check_fail("The delta should not be negative.\n" +
                   "<-0.1e0> was expected to be\n>=\n<0.0>.") do
          assert_in_delta(BigDecimal("0.5"),
                          BigDecimal("0.4"),
                          BigDecimal("-0.1"),
                          "message")
        end
      end

      def test_fail_without_delta
        check_fail("<0.140200000000000000001e1> -/+ <0.001> was expected to include\n" +
                    "<0.140400000000000000001e1>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.140200000000000000001e1>-<0.001>[0.140100000000000000001e1] <= " +
                    "<0.140200000000000000001e1>+<0.001>[0.140300000000000000001e1] < " +
                    "<0.140400000000000000001e1>" +
                    ">") do
          assert_in_delta(BigDecimal("1.40200000000000000001"),
                          BigDecimal("1.40400000000000000001"))
        end
      end
    end

    class TestAssertNotInDelta < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_in_delta(1.42, 1.44, 0.01)
        end
      end

      def test_pass_without_delta
        check_nothing_fails do
          assert_not_in_delta(1.402, 1.404)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_in_delta(0.5, 0.4, 0.09, "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            0.2
          end
          assert_not_in_delta(0.1, float_thing, 0.09)
        end
      end

      def test_pass_string_epxected
        check_nothing_fails do
          assert_not_in_delta("0.5", 0.4, 0.09)
        end
      end

      def test_fail
        check_fail("<1.4> -/+ <0.11> was expected to not include\n" +
                    "<1.5>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<1.4>-<0.11>[#{1.4 - 0.11}] <= " +
                    "<1.5> <= " +
                    "<1.4>+<0.11>[#{1.4 + 0.11}]" +
                    ">") do
          assert_not_in_delta(1.4, 1.5, 0.11)
        end
      end

      def test_fail_without_delta
        check_fail("<1.402> -/+ <0.001> was expected to not include\n" +
                    "<1.4021>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<1.402>-<0.001>[#{1.402 - 0.001}] <= " +
                    "<1.4021> <= " +
                    "<1.402>+<0.001>[#{1.402 + 0.001}]" +
                    ">") do
          assert_not_in_delta(1.402, 1.4021)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.5> -/+ <0.11> was expected to not include\n" +
                    "<0.4>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.5>-<0.11>[0.39] <= " +
                    "<0.4> <= " +
                    "<0.5>+<0.11>[0.61]" +
                    ">") do
          assert_not_in_delta(0.5, 0.4, 0.11, "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_not_in_delta(object, 0.4, 0.1)
        end
      end

      def test_fail_because_negaitve_delta
        check_fail("The delta should not be negative.\n" +
                    "<-0.11> was expected to be\n>=\n<0.0>.") do
          assert_not_in_delta(0.5, 0.4, -0.11, "message")
        end
      end
    end

    class TestAssertNotInDeltaBigDecimal < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_in_delta(BigDecimal("1.42000000000000000001"),
                              BigDecimal("1.42000000000000000002"),
                              BigDecimal("0.000000000000000000005"))
        end
      end

      def test_pass_without_delta
        check_nothing_fails do
          assert_not_in_delta(BigDecimal("1.40200000000000000001"),
                              BigDecimal("1.40400000000000000001"))
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_in_delta(BigDecimal("0.50000000000000000001"),
                              BigDecimal("0.50000000000000000002"),
                              BigDecimal("0.000000000000000000009"),
                              "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            0.2
          end
          assert_not_in_delta(BigDecimal("0.10000000000000000001"),
                              float_thing,
                              BigDecimal("0.09"))
        end
      end

      def test_pass_string_epxected
        check_nothing_fails do
          assert_not_in_delta("0.5",
                              BigDecimal("0.4"),
                              BigDecimal("0.09"))
        end
      end

      def test_fail
        check_fail("<0.140000000000000000001e1> -/+ <0.5e-19> was expected to not include\n" +
                    "<0.140000000000000000002e1>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.140000000000000000001e1>-<0.5e-19>[0.139999999999999999996e1] <= " +
                    "<0.140000000000000000002e1> <= " +
                    "<0.140000000000000000001e1>+<0.5e-19>[0.140000000000000000006e1]" +
                    ">") do
          assert_not_in_delta(BigDecimal("1.40000000000000000001"),
                              BigDecimal("1.40000000000000000002"),
                              BigDecimal("0.00000000000000000005"))
        end
      end

      def test_fail_without_delta
        check_fail("<0.140200000000000000001e1> -/+ <0.001> was expected to not include\n" +
                    "<0.140210000000000000001e1>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.140200000000000000001e1>-<0.001>" +
                    "[#{BigDecimal("1.40200000000000000001") - 0.001}] <= " +
                    "<0.140210000000000000001e1> <= " +
                    "<0.140200000000000000001e1>+<0.001>" +
                    "[#{BigDecimal("1.40200000000000000001") + 0.001}]" +
                    ">") do
          assert_not_in_delta(BigDecimal("1.40200000000000000001"),
                              BigDecimal("1.40210000000000000001"))
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.50000000000000000001e0> -/+ <0.5e-19> was expected to not include\n" +
                    "<0.50000000000000000002e0>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.50000000000000000001e0>-<0.5e-19>[0.49999999999999999996e0] <= " +
                    "<0.50000000000000000002e0> <= " +
                    "<0.50000000000000000001e0>+<0.5e-19>[0.50000000000000000006e0]" +
                    ">") do
          assert_not_in_delta(BigDecimal("0.50000000000000000001"),
                              BigDecimal("0.50000000000000000002"),
                              BigDecimal("0.00000000000000000005"),
                              "message")
        end
      end

      def test_fail_with_float_like_object
        object = Object.new
        def object.to_f
          0.4
        end
        inspected_object = AssertionMessage.convert(object)
        check_fail("<0.1e0> -/+ <0.5e0> was expected to not include\n" +
                    "<#{inspected_object}>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.1e0>-<0.5e0>[#{0.1 - 0.5}] <= " +
                    "<#{inspected_object}> <= " +
                    "<0.1e0>+<0.5e0>[#{0.1 + 0.5}]" +
                    ">") do
          assert_not_in_delta(BigDecimal("0.1"),
                              object,
                              BigDecimal("0.5"))
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_not_in_delta(object,
                              BigDecimal("0.4"),
                              BigDecimal("0.1"))
        end
      end

      def test_fail_because_negaitve_delta
        check_fail("The delta should not be negative.\n" +
                   "<-5.0e-20> was expected to be\n>=\n<0.0>.") do
          assert_not_in_delta(BigDecimal("+0.500000000000000000001"),
                              BigDecimal("+0.500000000000000000002"),
                              BigDecimal("-0.00000000000000000005"),
                              "message")
        end
      end
    end

    class TestAssertInEpsilon < TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_in_epsilon(10000, 9000, 0.1)
        end
      end

      def test_pass_without_epsilon
        check_nothing_fails do
          assert_in_epsilon(10000, 9991)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_in_epsilon(10000, 9000, 0.1, "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            9000.0
          end
          assert_in_epsilon(10000, float_thing, 0.1)
        end
      end

      def test_pass_string_expected
        check_nothing_fails do
          assert_in_epsilon("10000", 9000, 0.1)
        end
      end

      def test_pass_zero_expected
        check_nothing_fails do
          assert_in_epsilon(0, 0.00000001)
        end
      end

      def test_pass_minus_expected
        check_nothing_fails do
          assert_in_epsilon(-1, -1)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                    "was expected to include\n" +
                    "<8999>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<8999> < " +
                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
                    "<10000>+(<10000>*<0.1>)[11000.0]" +
                    ">") do
          assert_in_epsilon(10000, 8999, 0.1, "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_in_epsilon(object, 9000, 0.1)
        end
      end

      def test_fail_because_negaitve_epsilon
        check_fail("The epsilon should not be negative.\n" +
                    "<-0.1> was expected to be\n>=\n<0.0>.") do
          assert_in_epsilon(10000, 9000, -0.1, "message")
        end
      end

      def test_fail_without_epsilon
        check_fail("<10000> -/+ (<10000> * <0.001>)[10.0] " +
                    "was expected to include\n" +
                    "<10011>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<10000>-(<10000>*<0.001>)[9990.0] <= " +
                    "<10000>+(<10000>*<0.001>)[10010.0] < " +
                    "<10011>" +
                    ">") do
          assert_in_epsilon(10000, 10011)
        end
      end
    end

    class TestAssertInEpsilonBigDecimal < TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_in_epsilon(BigDecimal("1.0e1000"),
                            BigDecimal("0.9e1000"),
                            BigDecimal("0.1"))
        end
      end

      def test_pass_without_epsilon
        check_nothing_fails do
          assert_in_epsilon(BigDecimal("1.0e1000"),
                            BigDecimal("0.9991e1000"))
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_in_epsilon(BigDecimal("1.0e1000"),
                            BigDecimal("0.9e1000"),
                            BigDecimal("0.1"),
                            "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            9000.0
          end
          assert_in_epsilon(BigDecimal("10000"),
                            float_thing,
                            BigDecimal("0.1"))
        end
      end

      def test_pass_string_expected
        check_nothing_fails do
          assert_in_epsilon("10000",
                            BigDecimal("9000"),
                            BigDecimal("0.1"))
        end
      end

      def test_pass_zero_expected
        check_nothing_fails do
          assert_in_epsilon(BigDecimal("0"),
                            BigDecimal("1e-1000"))
        end
      end

      def test_pass_minus_expected
        check_nothing_fails do
          assert_in_epsilon(BigDecimal("-1"),
                            BigDecimal("-1"))
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.1e501> -/+ (<0.1e501> * <0.1e0>)[0.1e500] " +
                    "was expected to include\n" +
                    "<0.8999e500>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.8999e500> < " +
                    "<0.1e501>-(<0.1e501>*<0.1e0>)[0.9e500] <= " +
                    "<0.1e501>+(<0.1e501>*<0.1e0>)[0.11e501]" +
                    ">") do
          assert_in_epsilon(BigDecimal("1e500"),
                            BigDecimal("0.8999e500"),
                            BigDecimal("0.1"),
                            "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_in_epsilon(object,
                            BigDecimal("0.9e500"),
                            BigDecimal("0.1"))
        end
      end

      def test_fail_with_float_like_object
        if RUBY_ENGINE == "truffleruby"
          omit("This fails on TruffleRuby; " +
               "see https://github.com/test-unit/test-unit/pull/218 for details")
        end

        object = Object.new
        def object.to_f
          0.4
        end
        check_fail("<0.10000000000000000001e0> -/+ (<0.10000000000000000001e0> * <0.1e0>)" +
                   "[0.010000000000000002] was expected to include\n" +
                   "<#{object}>.\n" +
                   "\n" +
                   "Relation:\n" +
                   "<" +
                   "<0.10000000000000000001e0>-(<0.10000000000000000001e0>*<0.1e0>)" +
                   "[0.09] <= " +
                   "<0.10000000000000000001e0>+(<0.10000000000000000001e0>*<0.1e0>)" +
                   "[0.11000000000000001] < " +
                   "<#{object}>" +
                   ">"
                  ) do
          assert_in_epsilon(BigDecimal("0.10000000000000000001"),
                            object,
                            BigDecimal("0.1"))
        end
      end

      def test_fail_because_negaitve_epsilon
        check_fail("The epsilon should not be negative.\n" +
                    "<-0.1e0> was expected to be\n>=\n<0.0>.") do
          assert_in_epsilon(BigDecimal("1.0e500"),
                            BigDecimal("0.9e500"),
                            BigDecimal("-0.1"),
                            "message")
        end
      end

      def test_fail_without_epsilon
        check_fail("<0.1e501> -/+ (<0.1e501> * <0.001>)[0.1e498] " +
                    "was expected to include\n" +
                    "<0.10011e501>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.1e501>-(<0.1e501>*<0.001>)[0.999e500] <= " +
                    "<0.1e501>+(<0.1e501>*<0.001>)[0.1001e501] < " +
                    "<0.10011e501>" +
                    ">") do
          assert_in_epsilon(BigDecimal("1.0000e500"),
                            BigDecimal("1.0011e500"))
        end
      end
    end

    class TestAssertNotInEpsilon < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_in_epsilon(10000, 8999, 0.1)
        end
      end

      def test_pass_without_epsilon
        check_nothing_fails do
          assert_not_in_epsilon(10000, 9989)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_in_epsilon(10000, 8999, 0.1, "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            8999.0
          end
          assert_not_in_epsilon(10000, float_thing, 0.1)
        end
      end

      def test_pass_string_epxected
        check_nothing_fails do
          assert_not_in_epsilon("10000", 8999, 0.1)
        end
      end

      def test_fail
        check_fail("<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                    "was expected to not include\n" +
                    "<9000>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
                    "<9000> <= " +
                    "<10000>+(<10000>*<0.1>)[11000.0]" +
                    ">") do
          assert_not_in_epsilon(10000, 9000, 0.1)
        end
      end

      def test_fail_without_epsilon
        check_fail("<10000> -/+ (<10000> * <0.001>)[10.0] " +
                    "was expected to not include\n" +
                    "<9990>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<10000>-(<10000>*<0.001>)[9990.0] <= " +
                    "<9990> <= " +
                    "<10000>+(<10000>*<0.001>)[10010.0]" +
                    ">") do
          assert_not_in_epsilon(10000, 9990)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<10000> -/+ (<10000> * <0.1>)[1000.0] " +
                    "was expected to not include\n" +
                    "<9000>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<10000>-(<10000>*<0.1>)[9000.0] <= " +
                    "<9000> <= " +
                    "<10000>+(<10000>*<0.1>)[11000.0]" +
                    ">") do
          assert_not_in_epsilon(10000, 9000, 0.1, "message")
        end
      end

      def test_fail_with_float_like_object
        object = Object.new
        def object.to_f
          0.4
        end
        check_fail("<0.1e1001> -/+ (<0.1e1001> * <0.1e0>)" +
                   "[Infinity] was expected to not include\n" +
                   "<#{object}>.\n" +
                   "\n" +
                   "Relation:\n" +
                   "<" +
                   "<0.1e1001>-(<0.1e1001>*<0.1e0>)[NaN] <= " +
                   "<#{object}> <= " +
                   "<0.1e1001>+(<0.1e1001>*<0.1e0>)[Infinity]" +
                   ">"
                  ) do
          assert_not_in_epsilon(BigDecimal("1e1000"),
                                object,
                                BigDecimal("0.1"))
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_not_in_epsilon(object, 9000, 0.1)
        end
      end

      def test_fail_because_negaitve_epsilon
        check_fail("The epsilon should not be negative.\n" +
                    "<-0.1> was expected to be\n>=\n<0.0>.") do
          assert_not_in_epsilon(10000, 9000, -0.1, "message")
        end
      end
    end

    class TestAssertNotInEpsilonBigDecimal < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_in_epsilon(BigDecimal("1.0000e1000"),
                                BigDecimal("0.8999e1000"),
                                BigDecimal("0.1"))
        end
      end

      def test_pass_without_epsilon
        check_nothing_fails do
          assert_not_in_epsilon(BigDecimal("1.0000e1000"),
                                BigDecimal("0.9989e1000"))
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_in_epsilon(BigDecimal("1.0000e1000"),
                                BigDecimal("0.8999e1000"),
                                BigDecimal("0.1"),
                                "message")
        end
      end

      def test_pass_float_like_object
        check_nothing_fails do
          float_thing = Object.new
          def float_thing.to_f
            8999.0
          end
          assert_not_in_epsilon(BigDecimal("10000"),
                                float_thing,
                                BigDecimal("0.1"))
        end
      end

      def test_pass_string_epxected
        check_nothing_fails do
          assert_not_in_epsilon("10000",
                                BigDecimal("8999"),
                                BigDecimal("0.1"))
        end
      end

      def test_fail
        check_fail("<0.1e1001> -/+ (<0.1e1001> * <0.1e0>)[0.1e1000] " +
                    "was expected to not include\n" +
                    "<0.9e1000>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.1e1001>-(<0.1e1001>*<0.1e0>)[0.9e1000] <= " +
                    "<0.9e1000> <= " +
                    "<0.1e1001>+(<0.1e1001>*<0.1e0>)[0.11e1001]" +
                    ">") do
          assert_not_in_epsilon(BigDecimal("1.0e1000"),
                                BigDecimal("0.9e1000"),
                                BigDecimal("0.1"))
        end
      end

      def test_fail_without_epsilon
        check_fail("<0.1e1001> -/+ (<0.1e1001> * <0.001>)[0.1e998] " +
                    "was expected to not include\n" +
                    "<0.999e1000>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.1e1001>-(<0.1e1001>*<0.001>)[0.999e1000] <= " +
                    "<0.999e1000> <= " +
                    "<0.1e1001>+(<0.1e1001>*<0.001>)[0.1001e1001]" +
                    ">") do
          assert_not_in_epsilon(BigDecimal("1.000e1000"),
                                BigDecimal("0.999e1000"))
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<0.1e1001> -/+ (<0.1e1001> * <0.1e0>)[0.1e1000] " +
                    "was expected to not include\n" +
                    "<0.9e1000>.\n" +
                    "\n" +
                    "Relation:\n" +
                    "<" +
                    "<0.1e1001>-(<0.1e1001>*<0.1e0>)[0.9e1000] <= " +
                    "<0.9e1000> <= " +
                    "<0.1e1001>+(<0.1e1001>*<0.1e0>)[0.11e1001]" +
                    ">") do
          assert_not_in_epsilon(BigDecimal("1.0e1000"),
                                BigDecimal("0.9e1000"),
                                BigDecimal("0.1"),
                                "message")
        end
      end

      def test_fail_because_not_float_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The arguments must respond to to_f; " +
                    "the first float did not.\n" +
                    "<#{inspected_object}>.respond_to?(:to_f) expected\n" +
                    "(Class: )") do
          assert_not_in_epsilon(object,
                                BigDecimal("0.9e1000"),
                                BigDecimal("0.1"))
        end
      end

      def test_fail_because_negaitve_epsilon
        check_fail("The epsilon should not be negative.\n" +
                    "<-0.1e0> was expected to be\n>=\n<0.0>.") do
          assert_not_in_epsilon(BigDecimal("10000"),
                                BigDecimal("9000"),
                                BigDecimal("-0.1"),
                                "message")
        end
      end
    end

    class TestAssertInclude < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_include([1, 2, 3], 1)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_include([1, 2, 3], 1, "message")
        end
      end

      def test_fail
        check_fail("<[1, 2, 3]> was expected to include\n" +
                    "<4>.") do
          assert_include([1, 2, 3], 4)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<[1, 2, 3]> was expected to include\n" +
                    "<4>.") do
          assert_include([1, 2, 3], 4, "message")
        end
      end

      def test_fail_because_not_collection_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The collection must respond to :include?.\n" +
                    "<#{inspected_object}>.respond_to?(:include?) expected\n" +
                    "(Class: )") do
          assert_include(object, 1)
        end
      end
    end

    class TestAssertNotInclude < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_include([1, 2, 3], 5)
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_include([1, 2, 3], 5, "message")
        end
      end

      def test_fail
        check_fail("<[1, 2, 3]> was expected to not include\n" +
                    "<2>.") do
          assert_not_include([1, 2, 3], 2)
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<[1, 2, 3]> was expected to not include\n" +
                    "<2>.") do
          assert_not_include([1, 2, 3], 2, "message")
        end
      end

      def test_fail_because_not_collection_like_object
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The collection must respond to :include?.\n" +
                    "<#{inspected_object}>.respond_to?(:include?) expected\n" +
                    "(Class: )") do
          assert_not_include(object, 1)
        end
      end
    end

    class TestAssertEmpty < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_empty([])
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_empty([], "message")
        end
      end

      def test_fail
        check_fail("<[1]> was expected to be empty.") do
          assert_empty([1])
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<[1]> was expected to be empty.") do
          assert_empty([1], "message")
        end
      end

      def test_fail_because_no_empty_method
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The object must respond to :empty?.\n" +
                    "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
                    "(Class: )") do
          assert_empty(object)
        end
      end
    end

    class TestAssertNotEmpty < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_empty([1])
        end
      end

      def test_pass_with_message
        check_nothing_fails do
          assert_not_empty([1], "message")
        end
      end

      def test_fail
        check_fail("<[]> was expected to not be empty.") do
          assert_not_empty([])
        end
      end

      def test_fail_with_message
        check_fail("message.\n" +
                    "<[]> was expected to not be empty.") do
          assert_not_empty([], "message")
        end
      end

      def test_fail_because_no_empty_method
        object = Object.new
        inspected_object = AssertionMessage.convert(object)
        check_fail("The object must respond to :empty?.\n" +
                    "<#{inspected_object}>.respond_to?(:empty?) expected\n" +
                    "(Class: )") do
          assert_not_empty(object)
        end
      end
    end

    class TestAssertNotSend < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_not_send([[1, 2], :member?, 4], "message")
        end
      end

      def test_fail
        expected_message = <<-EOM
message.
<[1, 2]> was expected to respond to
 with not a true value but was
.
EOM
        check_fail(expected_message.chomp) do
          assert_not_send([[1, 2], :member?, 2], "message")
        end
      end
    end

    class TestAssertAll < Test::Unit::TestCase
      include AssertionCheckable

      def test_pass
        check_nothing_fails do
          assert_all([1, 2]) {|item| item > 0}
        end
      end

      def test_pass_message
        check_nothing_fails do
          assert_all([1, 2], "positive") {|item| item > 0}
        end
      end

      def test_pass_empty
        check_nothing_fails do
          assert_all([]) {|item| false}
        end
      end

      def test_fail
        expected_message = <<-EOM
message.
<[0, 1]> was expected to be all true values with the given block but was
<{0=>true, 1=>false}>
EOM
        check_fail(expected_message.chomp) do
          assert_all([0, 1], "message", &:zero?)
        end
      end
    end

    class TestAssertNothingLeakedMemory < Test::Unit::TestCase
      include AssertionCheckable

      def setup
        @data = "Hello!" * 100
        if ObjectSpace.respond_to?(:memsize_of)
          @data_size = ObjectSpace.memsize_of(@data)
        else
          @data_size = 0
        end
        if @data_size.zero?
          @data_size = @data.bytesize
        end
      end

      def test_pass
        check_nothing_fails do
          n_tries = 100_000
          assert_nothing_leaked_memory(@data_size * n_tries) do
            n_tries.times do
              @data.dup
            end
          end
        end
      end

      def test_pass_message
        check_nothing_fails do
          n_tries = 100_000
          assert_nothing_leaked_memory(@data_size * 100_000,
                                       :physical,
                                       "string") do
            n_tries.times do
              @data.dup
            end
          end
        end
      end

      def test_pass_target
        check_nothing_fails do
          n_tries = 100_000
          assert_nothing_leaked_memory(@data_size * 100_000,
                                       :virtual) do
            n_tries.times do
              @data.dup
            end
          end
        end
      end

      def test_fail
        actual_increased_size = 10000
        n_tries = 100_000
        max_increasable_size = -1
        expected_message = <<-MESSAGE
message.
<#{actual_increased_size}> was expected to be less than
<#{max_increasable_size}>.
        MESSAGE
        actual_message_normalizer = lambda do |message|
          message.gsub(/<\d+> was expected/,
                       "<#{actual_increased_size}> was expected")
        end
        check_fail(expected_message.chomp,
                   actual_message_normalizer: actual_message_normalizer) do
          strings = []
          assert_nothing_leaked_memory(max_increasable_size,
                                       :physical,
                                       "message") do
            n_tries.times do
              strings << @data.dup
            end
          end
        end
      end
    end

    class TestTemplate < Test::Unit::TestCase
      def test_incompatible_encoding_by_diff
        need_encoding
        assert_raise(AssertionFailedError) do
          assert_equal("UTF-8の日本語\n" * 3,
                       ("Shift_JISの日本語\n" * 3).force_encoding("ASCII-8BIT"))
        end
      end

      private
      def need_encoding
        omit("need Encoding") unless Object.const_defined?(:Encoding)
      end
    end
  end
end
test-unit-3.6.2/test/test-attribute-matcher.rb000066400000000000000000000014361456346657200214110ustar00rootroot00000000000000require 'test/unit'
require 'testunit-test-util'

class TestAttributeMatcher < Test::Unit::TestCase
  include TestUnitTestUtil

  def setup
    @test = {}
    @matcher = Test::Unit::AttributeMatcher.new(@test)
  end

  def test_nonexistent
    assert_false(@matcher.match?("nonexistent"))
  end

  def test_existent
    @test[:existent] = true
    assert_true(@matcher.match?("existent"))
  end

  def test_and
    @test[:slow] = true
    @test[:important] = true
    assert_true(@matcher.match?("important and slow"))
  end

  def test_complex
    @test[:tags] = [:slow, :web]
    @test[:bug] = "2929"
    assert_true(@matcher.match?("tags.include?(:web) or bug == '29'"))
  end

  def test_exception
    assert_raise(NoMethodError) do
      @matcher.match?("nonexistent > 100")
    end
  end
end
test-unit-3.6.2/test/test-attribute.rb000066400000000000000000000056471456346657200200000ustar00rootroot00000000000000class TestUnitAttribute < Test::Unit::TestCase
  class TestStack < Test::Unit::TestCase
    class << self
      def suite
        Test::Unit::TestSuite.new(name)
      end
    end

    class Stack
      def initialize
        @data = []
      end

      def push(data)
        @data.push(data)
      end

      def peek
        @data[-2]
      end

      def empty?
        @data.empty?
      end

      def size
        @data.size + 11
      end
    end

    def setup
      @stack = Stack.new
    end

    attribute :category, :accessor
    def test_peek
      @stack.push(1)
      @stack.push(2)
      assert_equal(2, @stack.peek)
    end

    attribute :bug, 1234
    def test_bug_1234
      assert_equal(0, @stack.size)
    end

    def test_no_attributes
      assert(@stack.empty?)
      @stack.push(1)
      assert(!@stack.empty?)
      assert_equal(1, @stack.size)
    end
  end

  def test_set_attributes
    test_for_accessor_category = TestStack.new("test_peek")
    assert_equal({"category" => :accessor},
                 test_for_accessor_category.attributes)

    test_for_bug_1234 = TestStack.new("test_bug_1234")
    assert_equal({"bug" => 1234}, test_for_bug_1234.attributes)

    test_no_attributes = TestStack.new("test_no_attributes")
    assert_equal({}, test_no_attributes.attributes)
  end

  def test_callback
    changed_attributes = []
    observer = Proc.new do |test_case, key, old_value, value, method_name|
      changed_attributes << [test_case, key, old_value, value, method_name]
    end

    test_case = Class.new(TestStack) do
      register_attribute_observer(:bug, &observer)
      attribute("bug", 9876, "test_bug_1234")
      attribute(:description, "Test for peek", "test_peek")
      attribute(:bug, 29, "test_peek")
    end

    assert_equal([
                  [test_case, "bug", 1234, 9876, "test_bug_1234"],
                  [test_case, "bug", nil, 29, "test_peek"],
                 ],
                 changed_attributes)
  end

  def test_attributes_with_prepended_module
    omit("Module#prepend is needed") unless Module.respond_to?(:prepend, true)
    test_case = Class.new(TestStack) do
      prepend Module.new
    end
    assert_equal({
                   "category" => :accessor,
                 },
                 test_case.attributes("test_peek"))
  end

  class TestDescription < self
    def test_decoration_style
      test_case = Class.new(TestStack) do
        description "Test for push"
        def test_push
        end
      end

      test_push = test_case.new("test_push")
      assert_equal({"description" => "Test for push"},
                   test_push.attributes)
    end

    def test_explicit_test_name_style
      test_case = Class.new(TestStack) do
        def test_push
        end
        description "Test for push", :test_push
      end

      test_push = test_case.new("test_push")
      assert_equal({"description" => "Test for push"},
                   test_push.attributes)
    end
  end
end
test-unit-3.6.2/test/test-code-snippet.rb000066400000000000000000000034121456346657200203530ustar00rootroot00000000000000# coding: utf-8

require "test-unit"
require "testunit-test-util"

class TestCodeSnippet < Test::Unit::TestCase
  include TestUnitTestUtil

  class TestJRuby < self
    def test_error_inside_jruby
      jruby_only_test

      backtrace = backtrace_from_jruby
      no_rb_entries = backtrace.find_all do |(file, _, _)|
        File.extname(file) != ".rb"
      end

      fetcher = Test::Unit::CodeSnippetFetcher.new
      snippets = no_rb_entries.collect do |(file, line, _)|
        fetcher.fetch(file, line)
      end
      assert_equal([[]] * no_rb_entries.size,
                   snippets)
    end

    private
    def backtrace_from_jruby
      begin
        java.util.Vector.new(-1)
      rescue Exception
        $@.collect do |entry|
          entry.split(/:/, 3)
        end
      else
        flunk("failed to raise an exception from JRuby.")
      end
    end
  end

  class TestDefaultExternal < self
    def suppress_warning
      verbose = $VERBOSE
      begin
        $VERBOSE = false
        yield
      ensure
        $VERBOSE = verbose
      end
    end

    def setup
      suppress_warning do
        @default_external = Encoding.default_external
      end
      @fetcher = Test::Unit::CodeSnippetFetcher.new
    end

    def teardown
      suppress_warning do
        Encoding.default_external = @default_external
      end
    end

    def test_windows_31j
      source = Tempfile.new(["test-code-snippet", ".rb"])
      source.puts(<<-SOURCE)
puts("あいうえお")
      SOURCE
      source.flush
      suppress_warning do
        Encoding.default_external = "Windows-31J"
      end
      assert_equal([
                     [1, "puts(\"あいうえお\")", {:target_line? => false}],
                   ],
                   @fetcher.fetch(source.path, 0))
    end
  end
end
test-unit-3.6.2/test/test-color-scheme.rb000066400000000000000000000074051456346657200203470ustar00rootroot00000000000000class TestUnitColorScheme < Test::Unit::TestCase
  def test_register
    inverted_scheme_spec = {
      "success" => {:name => "red"},
      "failure" => {:name => "green"},
    }
    Test::Unit::ColorScheme["inverted"] = inverted_scheme_spec
    assert_equal({
                   "success" => color("red"),
                   "failure" => color("green"),
                 },
                 Test::Unit::ColorScheme["inverted"].to_hash)
  end

  def test_new_with_colors
    scheme = Test::Unit::ColorScheme.new(:success => color("blue"),
                                         "failure" => color("green",
                                                            :underline => true))
    assert_equal({
                   "success" => color("blue"),
                   "failure" => color("green", :underline => true),
                 },
                 scheme.to_hash)
  end

  def test_new_with_spec
    scheme = Test::Unit::ColorScheme.new(:success => {
                                           :name => "blue",
                                           :bold => true
                                         },
                                         "failure" => {:name => "green"})
    assert_equal({
                   "success" => color("blue", :bold => true),
                   "failure" => color("green"),
                 },
                 scheme.to_hash)
  end

  private
  def color(name, options={})
    Test::Unit::Color.new(name, options)
  end

  module CleanEnvironment
    def setup
      @original_term, ENV["TERM"] = ENV["TERM"], nil
      @original_color_term, ENV["COLORTERM"] = ENV["COLORTERM"], nil
      @original_vte_version, ENV["VTE_VERSION"] = ENV["VTE_VERSION"], nil
      @original_github_actions, ENV["GITHUB_ACTIONS"] = ENV["GITHUB_ACTIONS"], nil
      ENV["TERM"] = "xterm"
    end

    def teardown
      ENV["TERM"] = @original_term
      ENV["COLORTERM"] = @original_color_term
      ENV["VTE_VERSION"] = @original_vte_version
      ENV["GITHUB_ACTIONS"] = @original_github_actions
    end
  end

  class TestFor8Colors < self
    include CleanEnvironment

    def test_default
      expected_schema_keys = [
        "pass",
        "pass-marker",
        "failure",
        "failure-marker",
        "pending",
        "pending-marker",
        "omission",
        "omission-marker",
        "notification",
        "notification-marker",
        "error",
        "error-marker",
        "case",
        "suite",
        "diff-inserted-tag",
        "diff-deleted-tag",
        "diff-difference-tag",
        "diff-inserted",
        "diff-deleted",
      ]
      assert_equal(expected_schema_keys.sort,
                   Test::Unit::ColorScheme.default.to_hash.keys.sort)
    end
  end

  class TestGuessAvailableColors < self
    include CleanEnvironment

    {
      "rxvt"                 => 8,
      "xterm-color"          => 8,
      "alacritty"            => 256,
      "iTerm.app"            => 256,
      "screen-256color"      => 256,
      "screenxterm-256color" => 256,
      "tmux-256color"        => 256,
      "vte-256color"         => 256,
      "vscode-direct"        => 2**24,
      "vte-direct"           => 2**24,
      "xterm-direct"         => 2**24,
    }.each do |term, colors|
      data("%20s => %8d" % [term, colors], {term: term, colors: colors})
    end
    def test_term_env(data)
      ENV["TERM"] = data[:term]
      assert_equal(data[:colors],
                   Test::Unit::ColorScheme.available_colors,
                   "Incorrect available_colors for TERM=%s" % [data[:term]])
    end
  end

  class TestDefaultScheme < self
    include CleanEnvironment

    def test_direct_color
      ENV["TERM"] = "xterm-direct"
      assert_equal(Test::Unit::ColorScheme.default_for_256_colors,
                   Test::Unit::ColorScheme.default)
    end
  end
end
test-unit-3.6.2/test/test-color.rb000066400000000000000000000030621456346657200171000ustar00rootroot00000000000000class TestUnitColor < Test::Unit::TestCase
  def test_color_escape_sequence
    assert_escape_sequence(["31"], color("red"))
    assert_escape_sequence(["32", "1"], color("green", :bold => true))
    assert_escape_sequence(["0"], color("reset"))
    assert_escape_sequence(["45"], color("magenta", :background => true))
  end

  def test_mix_color_escape_sequence
    assert_escape_sequence(["34", "1"],
                           mix_color([color("blue"),
                                      color("none", :bold => true)]))
    assert_escape_sequence(["34", "1", "4"],
                           mix_color([color("blue"),
                                      color("none", :bold => true)]) +
                           color("none", :underline => true))
    assert_escape_sequence(["34", "1", "4"],
                           color("blue") +
                           color("none", :bold => true) +
                           color("none", :underline => true))
  end

  def test_equal
    red = color("red")
    red_bold = color("red", :bold => true)

    assert_operator(red, :==, red)
    assert_not_equal(red, nil)
    assert_equal(red, color("red"))
    assert_not_equal(red, red_bold)
  end

  private
  def color(name, options={})
    Test::Unit::Color.new(name, options)
  end

  def mix_color(colors)
    Test::Unit::MixColor.new(colors)
  end

  def assert_escape_sequence(expected, color)
    assert_equal(expected, color.sequence)
    assert_match(/\e\[(?:\d+;)*\d+m/, color.escape_sequence)
    assert_equal(expected, color.escape_sequence[2..-2].split(";"))
  end
end
test-unit-3.6.2/test/test-data.rb000066400000000000000000000400031456346657200166670ustar00rootroot00000000000000require "testunit-test-util"

class TestData < Test::Unit::TestCase
  class Calc
    def initialize
    end

    def plus(augend, addend)
      augend + addend
    end
  end

  class TestCalc < Test::Unit::TestCase
    @@testing = false

    class << self
      def testing=(testing)
        @@testing = testing
      end
    end

    def valid?
      @@testing
    end

    def setup
      @calc = Calc.new
    end

    class TestDataSet < TestCalc
      data("positive positive" => {:expected => 4, :augend => 3, :addend => 1},
           "positive negative" => {:expected => -1, :augend => 1, :addend => -2})
      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end
    end

    class TestNData < TestCalc
      data("positive positive", {:expected => 4, :augend => 3, :addend => 1})
      data("positive negative", {:expected => -1, :augend => 1, :addend => -2})
      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end
    end

    class TestDynamicDataSet < TestCalc
      DATA_PROC = lambda do
        data_set = {}
        data_set["positive positive"] = {
          :expected => 3,
          :augend => 1,
          :addend => 2
        }
        data_set["positive negative"] = {
          :expected => -1,
          :augend => 1,
          :addend => -2
        }
        data_set
      end

      data(&DATA_PROC)
      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end
    end

    class TestDynamicDataSetKeep < TestCalc
      DATA_PROC = lambda do
        data_set = {}
        data_set["positive positive"] = {
          :expected => 3,
          :augend => 1,
          :addend => 2
        }
        data_set["positive negative"] = {
          :expected => -1,
          :augend => 1,
          :addend => -2
        }
        data_set
      end

      data(keep: true, &DATA_PROC)
      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end

      def test_plus_keep(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end
    end

    class TestLoadDataSet < TestCalc
      extend TestUnitTestUtil
      load_data(fixture_file_path("plus.csv"))
      def test_plus(data)
        assert_equal(data["expected"],
                     @calc.plus(data["augend"], data["addend"]))
      end
    end

    class TestSuperclass < TestCalc
      data("positive positive" => {:expected => 4, :augend => 3, :addend => 1},
           "positive negative" => {:expected => -1, :augend => 1, :addend => -2})
      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end

      class TestNormalTestInSubclass < self
        def test_plus
          assert_equal(2, @calc.plus(1, 1))
        end
      end
    end

    class TestMethod < TestCalc
      def data_test_plus
        {
          "positive positive" => {:expected => 4, :augend => 3, :addend => 1},
          "positive negative" => {:expected => -1, :augend => 1, :addend => -2},
        }
      end

      def test_plus(data)
        assert_equal(data[:expected],
                     @calc.plus(data[:augend], data[:addend]))
      end
    end

    class TestPatterns < TestCalc
      data(:x, [-1, 1, 0])
      data(:y, [-100, 100])
      data(:z, ["a", "b", "c"])
      def test_use_data(data)
      end
    end

    class TestPatternsHash < TestCalc
      data(:x, {
             "negative" => -1,
             "positive" => 1,
             "zero" => 0,
           })
      data(:y, {
             "negative" => -100,
             "positive" => 100,
           })
      data(:z, ["a", "b", "c"])
      def test_use_data(data)
      end
    end

    class TestPatternsKeep < TestCalc
      data(:x, [-1, 1, 0], keep: true)
      data(:y, [-100, 100], keep: true)
      data(:z, ["a", "b", "c"])
      def test_use_data(data)
      end

      def test_use_data_keep(data)
      end
    end

    class TestPatternsGroup < TestCalc
      data(:a, [-1, 1, 0], group: 1)
      data(:b, [:a, :b], group: 1)
      data(:x, [2, 9], group: :z)
      data(:y, ["a", "b", "c"], group: :z)
      def test_use_data(data)
      end
    end
  end

  def setup
    TestCalc.testing = true
  end

  def teardown
    TestCalc.testing = false
  end

  def test_data_no_arguments_without_block
    assert_raise(ArgumentError) do
      self.class.data
    end
  end

  data("data set",
       {
         :test_case => TestCalc::TestDataSet,
         :data_sets => [
           {
             "positive positive" => {
               :expected => 4,
               :augend => 3,
               :addend => 1,
             },
             "positive negative" => {
               :expected => -1,
               :augend => 1,
               :addend => -2,
             },
           },
         ],
       })
  data("n-data",
       {
         :test_case => TestCalc::TestNData,
         :data_sets => [
           {
             "positive positive" => {
               :expected => 4,
               :augend => 3,
               :addend => 1,
             },
           },
           {
             "positive negative" => {
               :expected => -1,
               :augend => 1,
               :addend => -2,
             },
           },
         ],
       })
  data("dynamic-data-set",
       {
         :test_case => TestCalc::TestDynamicDataSet,
         :data_sets => [TestCalc::TestDynamicDataSet::DATA_PROC],
       })
  data("load-data-set",
       {
         :test_case => TestCalc::TestLoadDataSet,
         :data_sets => [
           {
             "positive positive" => {
               "expected" => 4,
               "augend" => 3,
               "addend" => 1,
             },
           },
           {
             "positive negative" => {
               "expected" => -1,
               "augend" => 1,
               "addend" => -2,
             },
           },
         ],
       })
  def test_data(data)
    test_plus = data[:test_case].new("test_plus")
    data_sets = Test::Unit::DataSets.new
    data[:data_sets].each do |data_set|
      data_sets.add(data_set)
    end
    assert_equal(data_sets, test_plus[:data])
  end

  def test_data_dynamic_data_set_keep
    test = TestCalc::TestDynamicDataSetKeep.new("test_plus_keep")
    data_sets = Test::Unit::DataSets.new
    data_sets.add(TestCalc::TestDynamicDataSetKeep::DATA_PROC, {keep: true})
    assert_equal(data_sets, test[:data])
  end

  def test_data_patterns
    test = TestCalc::TestPatterns.new("test_use_data")
    data_sets = Test::Unit::DataSets.new
    data_sets << [:x, [-1, 1, 0]]
    data_sets << [:y, [-100, 100]]
    data_sets << [:z, ["a", "b", "c"]]
    assert_equal(data_sets, test[:data])
  end

  def test_data_patterns_keep
    test = TestCalc::TestPatternsKeep.new("test_use_data_keep")
    data_sets = Test::Unit::DataSets.new
    data_sets.add([:x, [-1, 1, 0]], {keep: true})
    data_sets.add([:y, [-100, 100]], {keep: true})
    assert_equal(data_sets, test[:data])
  end

  data("data set"         => TestCalc::TestDataSet,
       "n-data"           => TestCalc::TestNData,
       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
       "load-data-set"    => TestCalc::TestLoadDataSet)
  def test_suite(test_case)
    suite = test_case.suite
    assert_equal(["test_plus[positive negative](#{test_case.name})",
                  "test_plus[positive positive](#{test_case.name})"],
                 suite.tests.collect {|test| test.name}.sort)
  end

  def test_suite_patterns
    test_case = TestCalc::TestPatterns
    suite = test_case.suite
    assert_equal([
                   "test_use_data[x: -1, y: -100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: -1, y: -100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: -1, y: -100, z: \"c\"](#{test_case.name})",
                   "test_use_data[x: -1, y: 100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: -1, y: 100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: -1, y: 100, z: \"c\"](#{test_case.name})",
                   "test_use_data[x: 0, y: -100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: 0, y: -100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: 0, y: -100, z: \"c\"](#{test_case.name})",
                   "test_use_data[x: 0, y: 100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: 0, y: 100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: 0, y: 100, z: \"c\"](#{test_case.name})",
                   "test_use_data[x: 1, y: -100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: 1, y: -100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: 1, y: -100, z: \"c\"](#{test_case.name})",
                   "test_use_data[x: 1, y: 100, z: \"a\"](#{test_case.name})",
                   "test_use_data[x: 1, y: 100, z: \"b\"](#{test_case.name})",
                   "test_use_data[x: 1, y: 100, z: \"c\"](#{test_case.name})",
                 ],
                 suite.tests.collect {|test| test.name}.sort)
  end

  def test_suite_patterns_hash
    test_case = TestCalc::TestPatternsHash
    suite = test_case.suite
    names = [
      "test_use_data[x: negative, y: negative, z: \"a\"](#{test_case.name})",
      "test_use_data[x: negative, y: negative, z: \"b\"](#{test_case.name})",
      "test_use_data[x: negative, y: negative, z: \"c\"](#{test_case.name})",
      "test_use_data[x: negative, y: positive, z: \"a\"](#{test_case.name})",
      "test_use_data[x: negative, y: positive, z: \"b\"](#{test_case.name})",
      "test_use_data[x: negative, y: positive, z: \"c\"](#{test_case.name})",
      "test_use_data[x: positive, y: negative, z: \"a\"](#{test_case.name})",
      "test_use_data[x: positive, y: negative, z: \"b\"](#{test_case.name})",
      "test_use_data[x: positive, y: negative, z: \"c\"](#{test_case.name})",
      "test_use_data[x: positive, y: positive, z: \"a\"](#{test_case.name})",
      "test_use_data[x: positive, y: positive, z: \"b\"](#{test_case.name})",
      "test_use_data[x: positive, y: positive, z: \"c\"](#{test_case.name})",
      "test_use_data[x: zero, y: negative, z: \"a\"](#{test_case.name})",
      "test_use_data[x: zero, y: negative, z: \"b\"](#{test_case.name})",
      "test_use_data[x: zero, y: negative, z: \"c\"](#{test_case.name})",
      "test_use_data[x: zero, y: positive, z: \"a\"](#{test_case.name})",
      "test_use_data[x: zero, y: positive, z: \"b\"](#{test_case.name})",
      "test_use_data[x: zero, y: positive, z: \"c\"](#{test_case.name})",
    ]
    assert_equal(names,
                 suite.tests.collect {|test| test.name}.sort)
  end

  def test_suite_patterns_group
    test_case = TestCalc::TestPatternsGroup
    suite = test_case.suite
    assert_equal([
                   "test_use_data[group: 1, a: -1, b: :a](#{test_case.name})",
                   "test_use_data[group: 1, a: -1, b: :b](#{test_case.name})",
                   "test_use_data[group: 1, a: 0, b: :a](#{test_case.name})",
                   "test_use_data[group: 1, a: 0, b: :b](#{test_case.name})",
                   "test_use_data[group: 1, a: 1, b: :a](#{test_case.name})",
                   "test_use_data[group: 1, a: 1, b: :b](#{test_case.name})",
                   "test_use_data[group: :z, x: 2, y: \"a\"](#{test_case.name})",
                   "test_use_data[group: :z, x: 2, y: \"b\"](#{test_case.name})",
                   "test_use_data[group: :z, x: 2, y: \"c\"](#{test_case.name})",
                   "test_use_data[group: :z, x: 9, y: \"a\"](#{test_case.name})",
                   "test_use_data[group: :z, x: 9, y: \"b\"](#{test_case.name})",
                   "test_use_data[group: :z, x: 9, y: \"c\"](#{test_case.name})",
                 ],
                 suite.tests.collect {|test| test.name}.sort)
  end

  data("data set"         => TestCalc::TestDataSet,
       "n-data"           => TestCalc::TestNData,
       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
       "load-data-set"    => TestCalc::TestLoadDataSet,
       "superclass"       => TestCalc::TestSuperclass,
       "method"           => TestCalc::TestMethod)
  def test_run(test_case)
    result = _run_test(test_case)
    assert_equal("2 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "0 omissions, 0 notifications", result.to_s)
  end

  def test_run_normal_test_in_subclass
    result = _run_test(TestCalc::TestSuperclass::TestNormalTestInSubclass)
    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "0 omissions, 0 notifications", result.to_s)
  end

  data("data set"         => TestCalc::TestDataSet,
       "n-data"           => TestCalc::TestNData,
       "dynamic-data-set" => TestCalc::TestDynamicDataSet,
       "load-data-set"    => TestCalc::TestLoadDataSet)
  def test_equal(test_case)
    suite = test_case.suite
    positive_positive_test = suite.tests.find do |test|
      test.data_label == "positive positive"
    end
    suite.tests.delete(positive_positive_test)
    assert_equal(["test_plus[positive negative](#{test_case.name})"],
                 suite.tests.collect {|test| test.name}.sort)
  end

  data("true"    => {:expected => true,    :target => "true"},
       "false"   => {:expected => false,   :target => "false"},
       "integer" => {:expected => 1,       :target => "1"},
       "float"   => {:expected => 1.5,     :target => "1.5"},
       "string"  => {:expected => "hello", :target => "hello"})
  def test_normalize_value(data)
    loader = Test::Unit::Data::ClassMethods::Loader.new(self)
    assert_equal(data[:expected], loader.__send__(:normalize_value, data[:target]))
  end

  def _run_test(test_case)
    result = Test::Unit::TestResult.new
    test = test_case.suite
    yield(test) if block_given?
    test.run(result) {}
    result
  end

  class TestLoadData < Test::Unit::TestCase
    include TestUnitTestUtil
    def test_invalid_csv_file_name
      garbage = "X"
      file_name = "data.csv#{garbage}"
      assert_raise(ArgumentError, "unsupported file format: <#{file_name}>") do
        self.class.load_data(file_name)
      end
    end

    class TestFileFormat < self
      def setup
        self.class.current_attribute(:data).clear
      end

      class TestHeader < self
        data("csv" => "header.csv",
             "tsv" => "header.tsv")
        def test_normal(file_name)
          self.class.load_data(fixture_file_path(file_name))
          data_sets = Test::Unit::DataSets.new
          data_sets << {
            "empty string" => {
              "expected" => true,
              "target"   => ""
            }
          }
          data_sets << {
            "plain string" => {
              "expected" => false,
              "target"   => "hello"
            }
          }
          assert_equal(data_sets,
                       self.class.current_attribute(:data)[:value])
        end

        data("csv" => "header-label.csv",
             "tsv" => "header-label.tsv")
        def test_label(file_name)
          self.class.load_data(fixture_file_path(file_name))
          data_sets = Test::Unit::DataSets.new
          data_sets << {
            "upper case" => {
              "expected" => "HELLO",
              "label"    => "HELLO"
            }
          }
          data_sets << {
            "lower case" => {
              "expected" => "Hello",
              "label"    => "hello"
            }
          }
          assert_equal(data_sets,
                       self.class.current_attribute(:data)[:value])
        end
      end

      data("csv" => "no-header.csv",
           "tsv" => "no-header.tsv")
      def test_without_header(file_name)
        self.class.load_data(fixture_file_path(file_name))
        data_sets = Test::Unit::DataSets.new
        data_sets << {"empty string" => [true, ""]}
        data_sets << {"plain string" => [false, "hello"]}
        assert_equal(data_sets,
                     self.class.current_attribute(:data)[:value])
      end
    end
  end
end
test-unit-3.6.2/test/test-diff.rb000066400000000000000000000440731456346657200167010ustar00rootroot00000000000000class TestUnitDiff < Test::Unit::TestCase
  def test_binary_search_ranges
    assert_found_binary_search_ranges(5, [1..2, 4..5, 7..9])
    assert_not_found_binary_search_ranges(3, [1..2, 4..5, 7..9])
  end

  def test_to_indexes
    assert_to_indexes({"abc def" => [0, 2], "abc" => [1]},
                      ["abc def", "abc", "abc def"])

    assert_to_indexes({?a => [0, 3], ?b => [1], ?c => [2], ?d => [4]},
                      "abcad")

    assert_to_indexes({
                        ?1 => [0, 35],
                        ?t => [2, 5, 16],
                        ?e => [3, 14, 31, 38],
                        ?s => [4, 6, 12, 13, 20, 32, 44],
                        ?, => [7, 21, 33],
                        ?0 => [9, 23],
                        ?a => [11, 26],
                        ?r => [15, 30],
                        ?i => [17, 27, 41],
                        ?o => [18],
                        ?n => [19, 39, 42],
                        ?f => [25],
                        ?l => [28],
                        ?u => [29],
                        ?p => [37],
                        ?d => [40],
                        ?g => [43],
                      },
                      "1 tests, 0 assertions, 0 failures, 1 pendings") do |x|
      x == " "[0]
    end
  end

  def test_longest_match
    assert_longest_match([0, 1, 3],
                         %w(b c d), %w(a b c d x y z),
                         0, 2, 0, 7)
    assert_longest_match([1, 2, 2],
                         %w(b c d), %w(a b c d x y z),
                         1, 2, 0, 6)
    assert_longest_match([0, 0, 0],
                         %w(a b), %w(c),
                         0, 1, 0, 0)
    assert_longest_match([1, 0, 2],
                         %w(q a b x c d), %w(a b y c d f),
                         0, 5, 0, 5)
    assert_longest_match([4, 3, 2],
                         %w(q a b x c d), %w(a b y c d f),
                         3, 5, 2, 5)

    assert_longest_match([1, 0, 2], "qabxcd", "abycdf", 0, 5, 0, 5)
    assert_longest_match([0, 0, 1], "efg", "eg", 0, 2, 0, 1)
    assert_longest_match([2, 1, 1], "efg", "eg", 1, 2, 1, 1)
  end

  def test_longest_match_with_junk_predicate
    assert_longest_match([0, 4, 5], " abcd", "abcd abcd", 0, 4, 0, 8)
    assert_longest_match([1, 0, 4], " abcd", "abcd abcd", 0, 4, 0, 8) do |x|
      x == ' '[0]
    end
  end

  def test_matches
    assert_matches([[0, 0, 2],
                    [3, 2, 2]],
                   %w(a b x c d), %w(a b c d))
    assert_matches([[1, 0, 2],
                    [4, 3, 2]],
                   %w(q a b x c d), %w(a b y c d f))

    assert_matches([[1, 0, 2],
                    [4, 3, 2]],
                   "qabxcd", "abycdf")
    assert_matches([[0, 0, 1],
                    [2, 1, 1]],
                   "efg", "eg")
  end

  def test_matches_with_junk_predicate
    assert_matches([[0, 0, 23],
                    [24, 24, 11],
                    [36, 36, 9]],
                  "1 tests, 0 assertions, 1 failures, 0 pendings",
                  "1 tests, 0 assertions, 0 failures, 1 pendings")

    assert_matches([[0, 0, 1],
                    [1, 1, 8],
                    [9, 9, 1],
                    [10, 10, 13],
                    [24, 24, 11],
                    [36, 36, 9]],
                  "1 tests, 0 assertions, 1 failures, 0 pendings",
                  "1 tests, 0 assertions, 0 failures, 1 pendings") do |x|
      x == " "[0]
    end
  end

  def test_blocks
    assert_blocks([[0, 0, 2],
                   [3, 2, 2],
                   [5, 4, 0]],
                  %w(a b x c d), %w(a b c d))
    assert_blocks([[1, 0, 2],
                   [4, 3, 2],
                   [6, 6, 0]],
                  %w(q a b x c d), %w(a b y c d f))

    assert_blocks([[1, 0, 2],
                   [4, 3, 2],
                   [6, 6, 0]],
                  "qabxcd", "abycdf")
    assert_blocks([[0, 0, 1],
                   [2, 1, 1],
                   [3, 2, 0]],
                  "efg", "eg")
  end

  def test_blocks_with_junk_predicate
    assert_blocks([[0, 0, 23],
                   [24, 24, 11],
                   [36, 36, 9],
                   [45, 45, 0]],
                  "1 tests, 0 assertions, 1 failures, 0 pendings",
                  "1 tests, 0 assertions, 0 failures, 1 pendings") do |x|
      x == " "[0]
    end
  end

  def test_operations
    assert_operations([], %w(), %w())

    assert_operations([[:delete, 0, 1, 0, 0],
                       [:equal, 1, 3, 0, 2],
                       [:replace, 3, 4, 2, 3],
                       [:equal, 4, 6, 3, 5],
                       [:insert, 6, 6, 5, 6]],
                      %w(q a b x c d), %w(a b y c d f))

    assert_operations([[:delete, 0, 1, 0, 0],
                       [:equal, 1, 3, 0, 2],
                       [:replace, 3, 4, 2, 3],
                       [:equal, 4, 6, 3, 5],
                       [:insert, 6, 6, 5, 6]],
                      "qabxcd", "abycdf")

    assert_operations([[:equal, 0, 23, 0, 23],
                       [:replace, 23, 24, 23, 24],
                       [:equal, 24, 35, 24, 35],
                       [:replace, 35, 36, 35, 36],
                       [:equal, 36, 45, 36, 45]],
                      "1 tests, 0 assertions, 1 failures, 0 pendings",
                      "1 tests, 0 assertions, 0 failures, 1 pendings")

    assert_operations([[:equal, 0, 23, 0, 23],
                       [:replace, 23, 24, 23, 24],
                       [:equal, 24, 35, 24, 35],
                       [:replace, 35, 36, 35, 36],
                       [:equal, 36, 45, 36, 45]],
                      "1 tests, 0 assertions, 1 failures, 0 pendings",
                      "1 tests, 0 assertions, 0 failures, 1 pendings") do |x|
      x == " "[0]
    end
  end

  def test_grouped_operations
    assert_grouped_operations([[[:equal, 0, 0, 0, 0]]],
                              %w(),
                              %w())

    assert_grouped_operations([[[:equal, 0, 3, 0, 3]]],
                              %w(a b c),
                              %w(a b c))

    assert_grouped_operations([[[:equal, 0, 1, 0, 1],
                                [:replace, 1, 2, 1, 2],
                                [:equal, 2, 5, 2, 5]],
                               [[:equal, 8, 11, 8, 11],
                                [:replace, 11, 12, 11, 12],
                                [:equal, 12, 13, 12, 13],
                                [:delete, 13, 16, 13, 13],
                                [:equal, 16, 17, 13, 14],
                                [:replace, 17, 18, 14, 15],
                                [:equal, 18, 20, 15, 17]]],
                              %w(1 2 3 4 5 6 7 8 9 a b c d e f g h i j k),
                              %w(1 i 3 4 5 6 7 8 9 a b cX d h iX j k))
  end

  def test_ratio
    assert_ratio(0.75, "abcd", "bcde")
    assert_ratio(0.80, "efg", "eg")
  end

  def test_1_length_readable_diff
    differ = Test::Unit::Diff::ReadableDiffer.new(["0"], ["1"])
    def differ.cut_off_ratio
      0
    end
    def differ.default_ratio
      0
    end
    assert_equal("- 0\n" +
                 "? ^\n" +
                 "+ 1\n" +
                 "? ^",
                 differ.diff.join("\n"))
  end

  def test_same_contents_readable_diff
    assert_readable_diff("  aaa", ["aaa"], ["aaa"])
    assert_readable_diff("  aaa\n" \
                         "  bbb",
                         ["aaa", "bbb"], ["aaa", "bbb"])
  end

  def test_deleted_readable_diff
    assert_readable_diff("  aaa\n" \
                         "- bbb",
                         ["aaa", "bbb"], ["aaa"])
    assert_readable_diff("  aaa\n" \
                         "- bbb\n" \
                         "- ccc\n" \
                         "- ddd",
                         ["aaa", "bbb", "ccc", "ddd"], ["aaa"])
  end

  def test_inserted_readable_diff
    assert_readable_diff("  aaa\n" \
                         "+ bbb\n" \
                         "+ ccc\n" \
                         "+ ddd",
                         ["aaa"], ["aaa", "bbb", "ccc", "ddd"])
  end

  def test_replace_readable_diff
    assert_readable_diff("  aaa\n" \
                         "- bbb\n" \
                         "+ BbB\n" \
                         "  ccc\n" \
                         "- ddd\n" \
                         "- efg\n" \
                         "?  -\n" \
                         "+ eg",
                         ["aaa", "bbb", "ccc", "ddd", "efg"],
                         ["aaa", "BbB", "ccc", "eg"])

    assert_readable_diff("-  abcd xyz abc\n" \
                         "? -\n" \
                         "+ abcd abcd xyz abc\n" \
                         "?      +++++",
                         [" abcd xyz abc"],
                         ["abcd abcd xyz abc"])
  end

  def test_difference_readable_diff
    assert_readable_diff("- 1 tests, 0 assertions, 1 failures, 0 pendings\n" \
                         "?                        ^           ^\n" \
                         "+ 1 tests, 0 assertions, 0 failures, 1 pendings\n" \
                         "?                        ^           ^",
                         ["1 tests, 0 assertions, 1 failures, 0 pendings"],
                         ["1 tests, 0 assertions, 0 failures, 1 pendings"])
  end

  def test_complex_readable_diff
    assert_readable_diff("  aaa\n" \
                         "- bbb\n" \
                         "- ccc\n" \
                         "+ \n" \
                         "+   # \n" \
                         "  ddd",
                         ["aaa", "bbb", "ccc", "ddd"],
                         ["aaa", "", "  # ", "ddd"])

    assert_readable_diff("- one1\n" \
                         "?  ^\n" \
                         "+ ore1\n" \
                         "?  ^\n" \
                         "- two2\n" \
                         "- three3\n" \
                         "?  -   -\n" \
                         "+ tree\n" \
                         "+ emu",
                         ["one1", "two2", "three3"],
                         ["ore1", "tree", "emu"])
  end

  def test_empty_readable_diff
    assert_readable_diff("", [""], [""])
  end

  def test_unified_diff
    assert_unified_diff("",
                        ["one", "two", "three"],
                        ["one", "two", "three"],
                        "content 1",
                        "content 2")

    assert_unified_diff("--- Original Sat Jan 26 23:30:50 1991\n" \
                        "+++ Current Fri Jun 06 10:20:52 2003\n" \
                        "@@ -1,4 +1,4 @@\n" \
                        "+zero\n" \
                        " one\n" \
                        "-two\n" \
                        "-three\n" \
                        "+tree\n" \
                        " four",
                        ["one", "two", "three", "four"],
                        ["zero", "one", "tree", "four"],
                        "Original Sat Jan 26 23:30:50 1991",
                        "Current Fri Jun 06 10:20:52 2003",
                        :show_context => false)

    from = File.read(__FILE__).split(/\n/)
    to = from.dup
    target_line = __LINE__
    to[target_line - 1, 1] = []
    context = "  def test_unified_diff"
    summary = "@@ -#{target_line - 3},7 +#{target_line - 3},6 @@ #{context}"
    assert_unified_diff((["--- revision 10",
                          "+++ revision 11",
                          summary] +
                         from[target_line - 4, 3].collect {|line| " #{line}"} +
                         ["-#{from[target_line - 1]}"] +
                         from[target_line, 3].collect {|line| " #{line}"}
                         ).join("\n"),
                        from, to,
                        "revision 10",
                        "revision 11")
  end

  def test_empty_unified_diff
    assert_unified_diff("", [""], [""], "From", "To")
    assert_unified_diff("", [], [], "From", "To")
  end

  def test_diff_lines
    assert_diff_lines(["- ddd",
                       "- efg",
                       "?  -",
                       "+ eg"],
                      ["aaa", "bbb", "ccc", "ddd", "efg"],
                      ["aaa", "BbB", "ccc", "eg"],
                      3, 5, 3, 4)
  end

  def test_diff_line
    assert_diff_line(["- abcDefghiJkl",
                      "?    ^  ^  ^",
                      "+ abcdefGhijkl",
                      "?    ^  ^  ^"],
                     "abcDefghiJkl",
                     "abcdefGhijkl")

    assert_diff_line(["- bcDefghiJklx",
                      "?   ^  ^  ^  -",
                      "+ abcdefGhijkl",
                      "? +  ^  ^  ^"],
                     "bcDefghiJklx",
                     "abcdefGhijkl")
  end

  def test_empty_diff_line
    assert_diff_line(["- ",
                      "+ "],
                     "", "")
  end

  def test_format_diff_point
    assert_format_diff_point(["- \tabcDefghiJkl",
                              "? \t ^ ^  ^",
                              "+ \t\tabcdefGhijkl",
                              "? \t  ^ ^  ^"],
                             "\tabcDefghiJkl",
                             "\t\tabcdefGhijkl",
                             "  ^ ^  ^      ",
                             "+  ^ ^  ^      ")
    assert_format_diff_point(["- efg",
                              "?  ^",
                              "+ eg"],
                             "efg",
                             "eg",
                             " ^",
                             "")
  end

  def test_interesting_line
    from = ["class X",
            "  def find(x=0)",
            "    body",
            "  end",
            "end"]
    to = ["def xxx",
          "  raise 'not call me'",
          "end"]
    assert_interesting_line("  def find(x=0)",
                            from, to,
                            2, 1)
    assert_interesting_line("def xxx",
                            from, to,
                            2, 0)
    assert_interesting_line("class X",
                            from, to,
                            0, 0)
  end

  private
  def assert_found_binary_search_ranges(numeric, ranges)
    assert_true(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
                                                numeric,
                                                ranges))
  end

  def assert_not_found_binary_search_ranges(numeric, ranges)
    assert_false(Test::Unit::Diff::UTF8Line.send(:binary_search_ranges,
                                                 numeric,
                                                 ranges))
  end

  def assert_to_indexes(expected, to, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new([""], to, &junk_predicate)
    assert_equal(expected, matcher.instance_variable_get("@to_indexes"))
  end

  def assert_find_best_match_position(expected, from, to,
                                      from_start, from_end,
                                      to_start, to_end, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
    assert_equal(expected, matcher.send(:find_best_match_position,
                                        from_start, from_end,
                                        to_start, to_end))
  end

  def assert_longest_match(expected, from, to,
                           from_start, from_end,
                           to_start, to_end, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
    assert_equal(expected, matcher.longest_match(from_start, from_end,
                                                 to_start, to_end))
  end

  def assert_matches(expected, from, to, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
    assert_equal(expected, matcher.send(:matches))
  end

  def assert_blocks(expected, from, to, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
    assert_equal(expected, matcher.blocks)
  end

  def assert_operations(expected, from, to, &junk_predicate)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to, &junk_predicate)
    assert_equal(expected, matcher.operations)
  end

  def assert_grouped_operations(expected, from, to)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to)
    assert_equal(expected, matcher.grouped_operations)
  end

  def assert_ratio(expected, from, to)
    matcher = Test::Unit::Diff::SequenceMatcher.new(from, to)
    assert_in_delta(expected, 0.001, matcher.ratio)
  end

  def assert_readable_diff(expected, from, to)
    assert_equal(expected,
                 Test::Unit::Diff.readable(from.join("\n"), to.join("\n")))
  end

  def assert_unified_diff(expected, from, to, from_label, to_label, options={})
    options = options.merge(:from_label => from_label,
                            :to_label => to_label)
    assert_equal(expected,
                 Test::Unit::Diff.unified(from.join("\n"), to.join("\n"),
                                          options))
  end

  def assert_diff_lines(expected, from, to,
                        from_start, from_end,
                        to_start, to_end)
    differ = Test::Unit::Diff::ReadableDiffer.new(from, to)
    result = []
    differ.instance_variable_set("@result", result)
    differ.send(:diff_lines,
                from_start, from_end,
                to_start, to_end)
    assert_equal(expected, result)
  end

  def assert_diff_line(expected, from_line, to_line)
    differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
    result = []
    differ.instance_variable_set("@result", result)
    differ.send(:diff_line, from_line, to_line)
    assert_equal(expected, result)
  end

  def assert_format_diff_point(expected, from_line, to_line, from_tags, to_tags)
    differ = Test::Unit::Diff::ReadableDiffer.new([""], [""])
    result = []
    differ.instance_variable_set("@result", result)
    differ.send(:format_diff_point,
                from_line, to_line,
                from_tags, to_tags)
    assert_equal(expected, result)
  end

  def assert_interesting_line(expected, from, to, from_start, to_start)
    differ = Test::Unit::Diff::UnifiedDiffer.new(from, to)
    assert_equal(expected, differ.send(:find_interesting_line,
                                       from_start, to_start,
                                       :define_line?))
  end
end
test-unit-3.6.2/test/test-emacs-runner.rb000066400000000000000000000033631456346657200203650ustar00rootroot00000000000000require 'test/unit'
require 'test/unit/ui/emacs/testrunner'

class TestUnitEmacsRunner < Test::Unit::TestCase
  def test_format_failure_with_a_location
    runner = create_runner
    test_name = "test_failure"
    file = "/home/user/test_xxx.rb"
    line = "3"
    info = "in `xxx'"
    location = "#{file}:#{line}: #{info}"
    message = "FAIL!!!"
    failure = Test::Unit::Failure.new(test_name, [location], message)
    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
Failure:
#{test_name} [#{file}:#{line}]:
#{message}
EOM
  end

  def test_format_failure_with_locations
    runner = create_runner
    test_name = "test_failure"
    locations = ["/home/user/test_xxx.rb:3: in `xxx'",
                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
    message = "Many backtrace!!!"
    failure = Test::Unit::Failure.new(test_name, locations, message)
    assert_equal(<<-EOM.chomp, runner.send(:format_fault, failure))
Failure:
#{test_name}
#{locations.join("\n")}:
#{message}
EOM
  end

  def test_format_error
    runner = create_runner
    test_name = "test_error"
    message = "Error Message!!!"
    backtrace = ["/home/user/test_xxx.rb:3: in `xxx'",
                 "/home/user/yyy/test_yyy.rb:999: in `yyy'",
                 "/home/user/xyz/zzz.rb:29: in `zzz'"]
    exception = RuntimeError.new(message)
    exception.set_backtrace(backtrace)
    error = Test::Unit::Error.new(test_name, exception)
    assert_equal(<<-EOM.chomp, runner.send(:format_fault, error))
Error:
#{test_name}:
#{exception.class.name}: #{message}
#{backtrace.join("\n")}
EOM
  end

  private
  def create_runner(suite=nil)
    suite ||= Test::Unit::TestSuite.new
    Test::Unit::UI::Emacs::TestRunner.new(suite)
  end
end
test-unit-3.6.2/test/test-error.rb000066400000000000000000000012041456346657200171070ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'

module Test
  module Unit
    class TC_Error < TestCase
      TF_Exception = Struct.new('TF_Exception', :message, :backtrace)
      def test_display
        ex = TF_Exception.new("message1\nmessage2", ['line1', 'line2'])
        e = Error.new("name", ex)
        assert_equal("name: #{TF_Exception.name}: message1", e.short_display)
        assert_equal(<
#
# License: Ruby's

require "test-unit"
require "test/unit/fault-location-detector"
require "testunit-test-util"

class TestFaultLocationDetector < Test::Unit::TestCase
  include TestUnitTestUtil

  def setup
    @fetcher = Test::Unit::CodeSnippetFetcher.new
  end

  private
  def run_test_case(test_case)
    suite = test_case.suite
    result = Test::Unit::TestResult.new
    suite.run(result) {}
    result.faults[0]
  end

  def assert_detect(fault, target_line_number)
    detector = Test::Unit::FaultLocationDetector.new(fault, @fetcher)

    expected_backtrace_entries_until_detected = []
    fault.location.each do |backtrace_entry|
      expected_backtrace_entries_until_detected << backtrace_entry
      _, line_number, = detector.split_backtrace_entry(backtrace_entry)
      break if target_line_number == line_number
    end

    actual_backtrace_entries_until_detected = []
    fault.location.each do |backtrace_entry|
      actual_backtrace_entries_until_detected << backtrace_entry
      break if detector.target?(backtrace_entry)
    end

    assert_equal(expected_backtrace_entries_until_detected,
                 actual_backtrace_entries_until_detected)
  end

  module AlwaysFailAssertion
    private
    def assert_always_failed
      assert_true(false)
    end
  end

  class TestSourceLocation < self
    setup
    def setup_check_source_location
      unless lambda {}.respond_to?(:source_location)
        omit("Need Proc#source_location")
      end
    end

    def test_detected
      target_line_number = nil
      test_case = Class.new(Test::Unit::TestCase) do
        include AlwaysFailAssertion

        test "failed" do
          target_line_number = __LINE__; assert_always_failed
        end
      end

      fault = run_test_case(test_case)
      assert_detect(fault, target_line_number)
    end

    class TestOneLine < self
      def test_brace
        target_line_number = nil
        test_case = Class.new(Test::Unit::TestCase) do
          include AlwaysFailAssertion

          test("failed") {target_line_number = __LINE__; assert_always_failed}

          def other_method
            # body
          end
        end

        fault = run_test_case(test_case)
        assert_detect(fault, target_line_number)
      end

      def test_do_end
        target_line_number = nil
        test_case = Class.new(Test::Unit::TestCase) do
          include AlwaysFailAssertion

          test "failed" do target_line_number = __LINE__; assert_always_failed; end

          def other_method
            # body
          end
        end

        fault = run_test_case(test_case)
        assert_detect(fault, target_line_number)
      end
    end
  end

  class TestMethodName < self
    def test_detected
      test_case = Class.new(Test::Unit::TestCase) do
        include AlwaysFailAssertion

        class << self
          def target_line_number
            @@target_line_number
          end

          def target_line_number=(line_number)
            @@target_line_number = line_number
          end
        end

        def test_failed
          self.class.target_line_number = __LINE__; assert_always_failed
        end
      end

      fault = run_test_case(test_case)
      assert_detect(fault, test_case.target_line_number)
    end
  end

  class TestInBlock < self
    def test_in_block
      test_case = Class.new(Test::Unit::TestCase) do
        include AlwaysFailAssertion

        class << self
          def target_line_number
            @@target_line_number
          end

          def target_line_number=(line_number)
            @@target_line_number = line_number
          end
        end

        def run_yield
          yield
        end

        def test_failed
          run_yield do
            self.class.target_line_number = __LINE__; assert_always_failed
          end
        end
      end

      fault = run_test_case(test_case)
      assert_detect(fault, test_case.target_line_number)
    end
  end
end
test-unit-3.6.2/test/test-fixture.rb000066400000000000000000000533121456346657200174530ustar00rootroot00000000000000class TestUnitFixture < Test::Unit::TestCase
  module EmptyModule
  end

  class TestSetup < self
    def test_without_option
      expected_setup_calls = [:setup,
                              :custom_setup_method0,
                              :custom_setup_callback0,
                              :custom_setup_method1,
                              :custom_setup_callback1,
                              :custom_setup_method3,
                              :custom_setup_callback3]
      test_case = assert_setup(expected_setup_calls, [])
      assert_inherited_setup(expected_setup_calls, test_case)

      assert_inherited_setup([:setup], nil)
      assert_called_fixtures(expected_setup_calls, test_case)
    end

    def test_with_before_option
      expected_setup_calls = [:custom_setup_callback3,
                              :custom_setup_method3,
                              :custom_setup_method0,
                              :custom_setup_callback0,
                              :custom_setup_method1,
                              :custom_setup_callback1,
                              :setup]
      test_case = assert_setup(expected_setup_calls,
                               [[{:before => :append}],
                                [{:before => :append}],
                                [{:before => :prepend}],
                                [{:before => :prepend}]])
      assert_inherited_setup(expected_setup_calls, test_case)

      assert_inherited_setup([:setup], nil)
      assert_called_fixtures(expected_setup_calls, test_case)
    end

    def test_with_after_option
      expected_setup_calls = [:setup,
                              :custom_setup_callback3,
                              :custom_setup_method3,
                              :custom_setup_method0,
                              :custom_setup_callback0,
                              :custom_setup_method1,
                              :custom_setup_callback1]
      test_case = assert_setup(expected_setup_calls,
                               [[{:after => :append}],
                                [{:after => :append}],
                                [{:after => :prepend}],
                                [{:after => :prepend}]])
      assert_inherited_setup(expected_setup_calls, test_case)

      assert_inherited_setup([:setup], nil)
      assert_called_fixtures(expected_setup_calls, test_case)
    end

    def test_with_invalid_option
      assert_invalid_setup_option(:unknown => true)
      assert_invalid_setup_option(:before => :unknown)
      assert_invalid_setup_option(:after => :unknown)
    end

    def test_with_option_to_inherited
      expected_setup_calls = [:setup]
      test_case = assert_setup(expected_setup_calls, nil)
      assert_inherited_setup([:setup,
                              :custom_setup_method0,
                              :custom_setup_callback0,
                              :custom_setup_method1,
                              :custom_setup_callback1,
                              :custom_setup_method3,
                              :custom_setup_callback3],
                             test_case,
                             [])

      assert_inherited_setup([:setup], nil)
      assert_called_fixtures(expected_setup_calls, test_case)
    end

    private
    def assert_setup_customizable(expected, parent, options)
      test_case = Class.new(parent || Test::Unit::TestCase) do
        yield(self, :before) if block_given?

        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        def setup
          called(:setup)
        end

        setup(*(options[0] || [])) if options
        def custom_setup_method0
          called(:custom_setup_method0)
        end

        if options
          setup(*(options[0] || [])) do
            called(:custom_setup_callback0)
          end
        end

        def custom_setup_method1
          called(:custom_setup_method1)
        end
        setup(*[:custom_setup_method1, *(options[1] || [])]) if options

        if options
          setup(*(options[1] || [])) do
            called(:custom_setup_callback1)
          end
        end

        setup(*(options[2] || [])) if options
        def custom_setup_method2
          called(:custom_setup_method2)
        end
        unregister_setup(:custom_setup_method2) if options

        if options
          callback = lambda do
            called(:custom_setup_callback2)
          end
          setup(*(options[2] || []), &callback)
          unregister_setup(callback)
        end

        setup(*(options[3] || [])) if options
        def custom_setup_method3
          called(:custom_setup_method3)
        end

        if options
          setup(*(options[3] || [])) do
            called(:custom_setup_callback3)
          end
        end

        def test_nothing
        end

        yield(self, :after) if block_given?
      end

      assert_called_fixtures(expected, test_case)
      test_case
    end

    def assert_setup(expected, options)
      _test_case = assert_setup_customizable(expected, nil, options)
      assert_setup_customizable(expected, nil, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
      _test_case
    end

    def assert_inherited_setup(expected, parent, options=nil)
      _test_case = assert_setup_customizable(expected, parent, options)
      assert_setup_customizable(expected, parent, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
      _test_case
    end

    def assert_invalid_setup_option(option)
      assert_invalid_option(:setup, option)
    end
  end

  class TestCleanup < self
    def test_without_option
      expected_cleanup_calls = [:custom_cleanup_callback3,
                                :custom_cleanup_method3,
                                :custom_cleanup_callback1,
                                :custom_cleanup_method1,
                                :custom_cleanup_callback0,
                                :custom_cleanup_method0,
                                :cleanup]
      test_case = assert_cleanup(expected_cleanup_calls, [])
      assert_inherited_cleanup(expected_cleanup_calls, test_case)

      assert_inherited_cleanup([:cleanup], nil)
      assert_called_fixtures(expected_cleanup_calls, test_case)
    end

    def test_with_before_option
      expected_cleanup_calls = [:custom_cleanup_callback3,
                                :custom_cleanup_method3,
                                :custom_cleanup_method0,
                                :custom_cleanup_callback0,
                                :custom_cleanup_method1,
                                :custom_cleanup_callback1,
                                :cleanup]
      test_case = assert_cleanup(expected_cleanup_calls,
                                  [[{:before => :append}],
                                   [{:before => :append}],
                                   [{:before => :prepend}],
                                   [{:before => :prepend}]])
      assert_inherited_cleanup(expected_cleanup_calls, test_case)

      assert_inherited_cleanup([:cleanup], nil)
      assert_called_fixtures(expected_cleanup_calls, test_case)
    end

    def test_with_after_option
      expected_cleanup_calls = [:cleanup,
                                :custom_cleanup_callback3,
                                :custom_cleanup_method3,
                                :custom_cleanup_method0,
                                :custom_cleanup_callback0,
                                :custom_cleanup_method1,
                                :custom_cleanup_callback1]
      test_case = assert_cleanup(expected_cleanup_calls,
                                  [[{:after => :append}],
                                   [{:after => :append}],
                                   [{:after => :prepend}],
                                   [{:after => :prepend}]])
      assert_inherited_cleanup(expected_cleanup_calls, test_case)

      assert_inherited_cleanup([:cleanup], nil)
      assert_called_fixtures(expected_cleanup_calls, test_case)
    end

    def test_with_invalid_option
      assert_invalid_cleanup_option(:unknown => true)
      assert_invalid_cleanup_option(:before => :unknown)
      assert_invalid_cleanup_option(:after => :unknown)
    end

    def test_with_option_to_inherited
      expected_cleanup_calls = [:cleanup]
      test_case = assert_cleanup(expected_cleanup_calls, nil)
      assert_inherited_cleanup([:custom_cleanup_callback3,
                                :custom_cleanup_method3,
                                :custom_cleanup_callback1,
                                :custom_cleanup_method1,
                                :custom_cleanup_callback0,
                                :custom_cleanup_method0,
                                :cleanup],
                                test_case, [])

      assert_inherited_cleanup([:cleanup], nil)
      assert_called_fixtures(expected_cleanup_calls, test_case)
    end

    def test_with_exception
      test_case = Class.new(Test::Unit::TestCase) do
        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        def cleanup
          called(:cleanup)
          raise "cleanup"
        end

        cleanup
        def custom_cleanup_method0
          called(:custom_cleanup_method0)
          raise "custom_cleanup_method0"
        end

        cleanup do
          called(:custom_cleanup_callback0)
          raise "custom_cleanup_callback0"
        end

        cleanup
        def custom_cleanup_method1
          called(:custom_cleanup_method1)
          raise "custom_cleanup_method1"
        end

        cleanup do
          called(:custom_cleanup_callback1)
          raise "custom_cleanup_callback1"
        end

        def test_nothing
        end
      end

      assert_called_fixtures([:custom_cleanup_callback1],
                             test_case)
    end

    private
    def assert_cleanup_customizable(expected, parent, options)
      test_case = Class.new(parent || Test::Unit::TestCase) do
        yield(self, :before) if block_given?

        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        def cleanup
          called(:cleanup)
        end

        cleanup(*(options[0] || [])) if options
        def custom_cleanup_method0
          called(:custom_cleanup_method0)
        end

        if options
          cleanup(*(options[0] || [])) do
            called(:custom_cleanup_callback0)
          end
        end

        def custom_cleanup_method1
          called(:custom_cleanup_method1)
        end
        cleanup(*[:custom_cleanup_method1, *(options[1] || [])]) if options

        if options
          cleanup(*(options[1] || [])) do
            called(:custom_cleanup_callback1)
          end
        end

        cleanup(*(options[2] || [])) if options
        def custom_cleanup_method2
          called(:custom_cleanup_method2)
        end
        unregister_cleanup(:custom_cleanup_method2) if options

        if options
          callback = lambda do
            called(:custom_cleanup_callback2)
          end
          cleanup(*(options[2] || []), &callback)
          unregister_cleanup(callback)
        end

        cleanup(*(options[3] || [])) if options
        def custom_cleanup_method3
          called(:custom_cleanup_method3)
        end

        if options
          cleanup(*(options[3] || [])) do
            called(:custom_cleanup_callback3)
          end
        end

        def test_nothing
        end

        yield(self, :after) if block_given?
      end

      assert_called_fixtures(expected, test_case)
      test_case
    end

    def assert_cleanup(expected, options)
      assert_cleanup_customizable(expected, nil, options)
      assert_cleanup_customizable(expected, nil, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
    end

    def assert_inherited_cleanup(expected, parent, options=nil)
      assert_cleanup_customizable(expected, parent, options)
      assert_cleanup_customizable(expected, parent, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
    end

    def assert_invalid_cleanup_option(option)
      assert_invalid_option(:cleanup, option)
    end
  end

  class TestTeardown < self
    def test_without_option
      expected_teardown_calls = [:custom_teardown_callback3,
                                 :custom_teardown_method3,
                                 :custom_teardown_callback1,
                                 :custom_teardown_method1,
                                 :custom_teardown_callback0,
                                 :custom_teardown_method0,
                                 :teardown]
      test_case = assert_teardown(expected_teardown_calls, [])
      assert_inherited_teardown(expected_teardown_calls, test_case)

      assert_inherited_teardown([:teardown], nil)
      assert_called_fixtures(expected_teardown_calls, test_case)
    end

    def test_with_before_option
      expected_teardown_calls = [:custom_teardown_callback3,
                                 :custom_teardown_method3,
                                 :custom_teardown_method0,
                                 :custom_teardown_callback0,
                                 :custom_teardown_method1,
                                 :custom_teardown_callback1,
                                 :teardown]
      test_case = assert_teardown(expected_teardown_calls,
                                  [[{:before => :append}],
                                   [{:before => :append}],
                                   [{:before => :prepend}],
                                   [{:before => :prepend}]])
      assert_inherited_teardown(expected_teardown_calls, test_case)

      assert_inherited_teardown([:teardown], nil)
      assert_called_fixtures(expected_teardown_calls, test_case)
    end

    def test_with_after_option
      expected_teardown_calls = [:teardown,
                                 :custom_teardown_callback3,
                                 :custom_teardown_method3,
                                 :custom_teardown_method0,
                                 :custom_teardown_callback0,
                                 :custom_teardown_method1,
                                 :custom_teardown_callback1]
      test_case = assert_teardown(expected_teardown_calls,
                                  [[{:after => :append}],
                                   [{:after => :append}],
                                   [{:after => :prepend}],
                                   [{:after => :prepend}]])
      assert_inherited_teardown(expected_teardown_calls, test_case)

      assert_inherited_teardown([:teardown], nil)
      assert_called_fixtures(expected_teardown_calls, test_case)
    end

    def test_with_invalid_option
      assert_invalid_teardown_option(:unknown => true)
      assert_invalid_teardown_option(:before => :unknown)
      assert_invalid_teardown_option(:after => :unknown)
    end

    def test_with_option_to_inherited
      expected_teardown_calls = [:teardown]
      test_case = assert_teardown(expected_teardown_calls, nil)
      assert_inherited_teardown([:custom_teardown_callback3,
                                 :custom_teardown_method3,
                                 :custom_teardown_callback1,
                                 :custom_teardown_method1,
                                 :custom_teardown_callback0,
                                 :custom_teardown_method0,
                                 :teardown],
                                test_case, [])

      assert_inherited_teardown([:teardown], nil)
      assert_called_fixtures(expected_teardown_calls, test_case)
    end

    def test_with_exception
      test_case = Class.new(Test::Unit::TestCase) do
        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        def teardown
          called(:teardown)
          raise "teardown"
        end

        teardown
        def custom_teardown_method0
          called(:custom_teardown_method0)
          raise "custom_teardown_method0"
        end

        teardown do
          called(:custom_teardown_callback0)
          raise "custom_teardown_callback0"
        end

        teardown
        def custom_teardown_method1
          called(:custom_teardown_method1)
          raise "custom_teardown_method1"
        end

        teardown do
          called(:custom_teardown_callback1)
          raise "custom_teardown_callback1"
        end

        def test_nothing
        end
      end

      assert_called_fixtures([:custom_teardown_callback1,
                              :custom_teardown_method1,
                              :custom_teardown_callback0,
                              :custom_teardown_method0,
                              :teardown],
                             test_case)
    end

    def test_nested
      called = []
      parent_test_case = Class.new(Test::Unit::TestCase) do
        teardown do
          called << :parent
        end
      end

      child_test_case = Class.new(parent_test_case) do
        teardown do
          called << :child
        end

        def test_nothing
        end
      end

      run_test_nothing(child_test_case)
      assert_equal([:child, :parent],
                   called)
    end

    def test_setup_with_block
      test_case = Class.new(Test::Unit::TestCase) do
        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        setup
        def setup1
          called(:setup1)
          begin
            yield
            called(:setup1_after_yield)
          ensure
            called(:setup1_teardown)
          end
        end

        setup
        def setup2
          called(:setup2)
          begin
            yield
            called(:setup2_after_yield)
          ensure
            called(:setup2_teardown)
          end
        end

        def teardown
          called(:teardown)
        end

        def test_nothing
          called(:test)
          flunk
          called(:test_after_failure)
        end
      end

      assert_called_fixtures([
                               :setup1,
                               :setup2,
                               :test,
                               :setup2_teardown,
                               :setup1_teardown,
                               :teardown,
                             ],
                             test_case)
    end

    private
    def assert_teardown_customizable(expected, parent, options)
      test_case = Class.new(parent || Test::Unit::TestCase) do
        yield(self, :before) if block_given?

        def called_ids
          @called_ids ||= []
        end

        def called(id)
          called_ids << id
        end

        def teardown
          called(:teardown)
        end

        teardown(*(options[0] || [])) if options
        def custom_teardown_method0
          called(:custom_teardown_method0)
        end

        if options
          teardown(*(options[0] || [])) do
            called(:custom_teardown_callback0)
          end
        end

        def custom_teardown_method1
          called(:custom_teardown_method1)
        end
        teardown(*[:custom_teardown_method1, *(options[1] || [])]) if options

        if options
          teardown(*(options[1] || [])) do
            called(:custom_teardown_callback1)
          end
        end

        teardown(*(options[2] || [])) if options
        def custom_teardown_method2
          called(:custom_teardown_method2)
        end
        unregister_teardown(:custom_teardown_method2) if options

        if options
          callback = lambda do
            called(:custom_teardown_callback2)
          end
          teardown(*(options[2] || []), &callback)
          unregister_teardown(callback)
        end

        teardown(*(options[3] || [])) if options
        def custom_teardown_method3
          called(:custom_teardown_method3)
        end

        if options
          teardown(*(options[3] || [])) do
            called(:custom_teardown_callback3)
          end
        end

        def test_nothing
        end

        yield(self, :after) if block_given?
      end

      assert_called_fixtures(expected, test_case)
      test_case
    end

    def assert_teardown(expected, options)
      assert_teardown_customizable(expected, nil, options)
      assert_teardown_customizable(expected, nil, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
    end

    def assert_inherited_teardown(expected, parent, options=nil)
      assert_teardown_customizable(expected, parent, options)
      assert_teardown_customizable(expected, parent, options) do |test_case, tag|
        test_case.send(:include, EmptyModule) if tag == :before
      end
    end

    def assert_invalid_teardown_option(option)
      assert_invalid_option(:teardown, option)
    end
  end

  private
  def run_test_nothing(test_case)
    test = test_case.new("test_nothing")
    test.run(Test::Unit::TestResult.new) {}
    test
  end

  def assert_called_fixtures(expected, test_case)
    test = run_test_nothing(test_case)
    assert_equal(expected, test.called_ids)
  end

  def assert_invalid_option(fixture_type, option)
    exception = assert_raise(ArgumentError) do
      Class.new(Test::Unit::TestCase) do
        def test_nothing
        end

        send(fixture_type, option)
        def fixture
        end
      end
    end
    assert_equal("must be {:before => :prepend}, {:before => :append}, " +
                 "{:after => :prepend} or {:after => :append}" +
                 ": #{option.inspect}",
                 exception.message)
  end
end
test-unit-3.6.2/test/test-notification.rb000066400000000000000000000014011456346657200204430ustar00rootroot00000000000000require 'test/unit'
require 'testunit-test-util'

class TestUnitNotification < Test::Unit::TestCase
  include TestUnitTestUtil

  class TestCase < Test::Unit::TestCase
    class << self
      def suite
        Test::Unit::TestSuite.new(name)
      end
    end

    def test_notify
      notify("1st notify")
      notify("2nd notify. Reach here.")
    end
  end

  def test_notify
    result = _run_test("test_notify")
    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "0 omissions, 2 notifications",
                 result.to_s)
    assert_fault_messages(["1st notify", "2nd notify. Reach here."],
                          result.notifications)
  end

  private
  def _run_test(name)
    super(TestCase, name)
  end
end
test-unit-3.6.2/test/test-omission.rb000066400000000000000000000044751456346657200176330ustar00rootroot00000000000000require 'test/unit'
require 'testunit-test-util'

class TestUnitOmission < Test::Unit::TestCase
  include TestUnitTestUtil

  class TestCase < Test::Unit::TestCase
    class << self
      def suite
        Test::Unit::TestSuite.new(name)
      end
    end

    def test_omit
      omit("1st omit")
      omit("2nd omit. Should not be reached here.")
      assert(true, "Should not be reached here too.")
    end

    def test_omit_with_condition
      omit_if(false, "Never omit.")
      omit_unless(true, "Never omit too.")
      omit_if(true, "Should omit.")
      omit("The last omit. Should not be reached here.")
    end

    def test_omit_with_block
      omit("Omit block") do
        flunk("Should not be reached here.")
      end
      assert(true, "Should be reached here.")
    end

    def test_omit_with_block_and_condition
      omit_if(false, "Never omit.") do
        assert(true, "Should be reached here.")
      end
      omit_if(true, "Should omit.") do
        flunk("Never reached here.")
      end
      assert(true, "Should be reached here too.")
    end
  end

  def test_omit
    result = _run_test("test_omit")
    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "1 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["1st omit"], result.omissions)
  end

  def test_omit_with_condition
    result = _run_test("test_omit_with_condition")
    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "1 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["Should omit."], result.omissions)
  end

  def test_omit_with_block
    result = _run_test("test_omit_with_block")
    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "1 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["Omit block"], result.omissions)
  end

  def test_omit_with_condition_and_block
    result = _run_test("test_omit_with_block_and_condition")
    assert_equal("1 tests, 2 assertions, 0 failures, 0 errors, 0 pendings, " \
                 "1 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["Should omit."], result.omissions)
  end

  private
  def _run_test(name)
    super(TestCase, name)
  end
end
test-unit-3.6.2/test/test-pending.rb000066400000000000000000000037271456346657200174160ustar00rootroot00000000000000require 'test/unit'
require 'testunit-test-util'

class TestUnitPending < Test::Unit::TestCase
  include TestUnitTestUtil

  class TestCase < Test::Unit::TestCase
    class << self
      def suite
        Test::Unit::TestSuite.new(name)
      end
    end

    def test_pend
      pend("1st pend")
      pend("2nd pend. Should not be reached here.")
      assert(true, "Should not be reached here too.")
    end

    def test_pend_with_failure_in_block
      pend("Wait a minute") do
        raise "Not implemented yet"
      end
      assert(true, "Reached here.")
    end

    def test_pend_with_no_failure_in_block
      pend("Wait a minute") do
        "Nothing raised"
      end
      assert(true, "Not reached here.")
    end
  end

  def test_pend
    test = nil
    result = _run_test("test_pend") {|t| test = t}
    assert_equal("1 tests, 0 assertions, 0 failures, 0 errors, 1 pendings, " \
                 "0 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["1st pend"], result.pendings)
    assert_true(test.interrupted?)
  end

  def test_pend_with_failure_in_block
    test = nil
    result = _run_test("test_pend_with_failure_in_block") {|t| test = t}
    assert_equal("1 tests, 1 assertions, 0 failures, 0 errors, 1 pendings, " \
                 "0 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["Wait a minute"], result.pendings)
    assert_false(test.interrupted?)
  end

  def test_pend_with_no_failure_in_block
    test = nil
    result = _run_test("test_pend_with_no_failure_in_block") {|t| test = t}
    assert_equal("1 tests, 1 assertions, 1 failures, 0 errors, 0 pendings, " \
                 "0 omissions, 0 notifications",
                 result.to_s)
    assert_fault_messages(["Pending block should not be passed: Wait a minute."],
                          result.failures)
    assert_true(test.interrupted?)
  end

  private
  def _run_test(name, &block)
    super(TestCase, name, &block)
  end
end
test-unit-3.6.2/test/test-priority.rb000066400000000000000000000074401456346657200176470ustar00rootroot00000000000000require 'test/unit'

class TestUnitPriority < Test::Unit::TestCase
  class TestCase < Test::Unit::TestCase
    class << self
      def suite
        Test::Unit::TestSuite.new(name)
      end
    end

    priority :must
    def test_must
      assert(true)
    end

    def test_must_inherited
      assert(true)
    end

    priority :important
    def test_important
      assert(true)
    end

    def test_important_inherited
      assert(true)
    end

    priority :high
    def test_high
      assert(true)
    end

    def test_high_inherited
      assert(true)
    end

    priority :normal
    def test_normal
      assert(true)
    end

    def test_normal_inherited
      assert(true)
    end

    priority :low
    def test_low
      assert(true)
    end

    def test_low_inherited
      assert(true)
    end

    priority :never
    def test_never
      assert(true)
    end

    def test_never_inherited
      assert(true)
    end
  end

  def test_priority_must
    assert_priority("must", 1.0, 0.0001)
  end

  def test_priority_important
    assert_priority("important", 0.9, 0.09)
  end

  def test_priority_high
    assert_priority("high", 0.70, 0.1)
  end

  def test_priority_normal
    assert_priority("normal", 0.5, 0.1)
  end

  def test_priority_low
    assert_priority("low", 0.25, 0.1)
  end

  def test_priority_never
    assert_priority("never", 0.0, 0.0001)
  end

  def assert_priority(priority, expected, delta)
    assert_need_to_run("test_#{priority}", expected, delta)
    assert_need_to_run("test_#{priority}_inherited", expected, delta)
  end

  def assert_need_to_run(test_name, expected, delta)
    test = TestCase.new(test_name)
    n = 1000
    n_need_to_run = 0
    n.times do |i|
      n_need_to_run += 1 if Test::Unit::Priority::Checker.need_to_run?(test)
    end
    assert_in_delta(expected, n_need_to_run.to_f / n, delta)
  end

  class TestClassName < self
    def test_colon
      assert_escaped_name("Test_colon__colon_Priority", "Test::Priority")
    end

    def test_space
      assert_escaped_name("test_priority", "test priority")
    end

    def test_slash
      assert_escaped_name("test_priority", "test/priority")
    end

    def test_back_slash
      assert_escaped_name("test_priority", "test\/priority")
    end

    def test_question
      assert_escaped_name("#question.predicate", "#question?")
    end

    def test_exclamation
      assert_escaped_name("#exclamation.destructive", "#exclamation!")
    end

    def test_equal
      assert_escaped_name("#equal.equal", "#equal=")
    end

    def assert_escaped_name(expected, class_name)
      checker = Checker.new(nil)
      escaped_class_name = checker.send(:escape_class_name, class_name)
      assert_equal(expected, escaped_class_name)
    end
  end

  class TestFileName < self
    class SpecialNameTestCase < Test::Unit::TestCase
      class << self
        def suite
          Test::Unit::TestSuite.new(name)
        end
      end

      def test_question?
      end

      def test_exclamation!
      end

      def test_equal=
      end

      test "have space" do
      end
    end

    def test_question
      assert_escaped_name("test_colon__#question.predicate_case",
                          "test: #question? case")
    end

    def test_exclamation
      assert_escaped_name("test_colon__#exclamation.destructive_case",
                          "test: #exclamation! case")
    end

    def test_equal
      assert_escaped_name("test_colon__#equal.equal_case",
                          "test: #equal= case")
    end

    def assert_escaped_name(expected, test_method_name)
      checker = Checker.new(SpecialNameTestCase.new(test_method_name))
      passed_file = checker.send(:passed_file)
      method_name_component = File.basename(File.dirname(passed_file))
      assert_equal(expected, method_name_component)
    end
  end
end
test-unit-3.6.2/test/test-test-case.rb000066400000000000000000001103711456346657200176540ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2008-2014  Kouhei Sutou 
# Copyright:: Copyright (c) 2011  Haruka Yoshihara 
# Copyright:: Copyright (c) 2000-2002  Nathaniel Talbott
# License:: Ruby license.

require 'test/unit'

module Test
  module Unit
    class TestTestCase < TestCase
      self.test_order = :random
      def test_creation
        test_case = Class.new(TestCase) do
          def test_with_arguments(arg1, arg2)
          end
        end

        test = test_case.new(:test_with_arguments)
        check("Should have caught an invalid test when there are arguments",
              !test.valid?)

        test = test_case.new(:non_existent_test)
        check("Should have caught an invalid test when the method does not exist",
              !test.valid?)
      end

      def setup
        @tc_failure_error = Class.new(TestCase) do
          def test_failure
            assert_block("failure") do
              false
            end
          end
          def test_error
            1 / 0
          end
          def test_nested_failure
            nested
          end
          def nested
            assert_block("nested") do
              false
            end
          end
          def return_passed?
            return passed?
          end
        end

        def @tc_failure_error.name
          "TC_FailureError"
        end
      end

      def jruby_backtrace_entry?(entry)
        entry.start_with?("org/jruby/")
      end

      def rubinius_backtrace_entry?(entry)
        entry.start_with?("kernel/")
      end

      def internal_backtrace_entry?(entry)
        entry.start_with?(" fault.class,
            :message   => fault.message,
            :test_name => fault.test_name,
            :location  => normalize_location(fault.location),
          }
        end
        assert_equal([
                       {
                         :class     => Failure,
                         :message   => "failure",
                         :test_name => "test_failure(TC_FailureError)",
                         :location  => [
                           "#{__FILE__}:0:in 'test_failure'",
                           "#{__FILE__}:0:in '#{__method__}'",
                         ],
                       },
                     ],
                     fault_details)

        assert do
          not test_case.passed?
        end
        assert_equal([
                       [TestCase::STARTED,         test_case.name],
                       [TestCase::STARTED_OBJECT,  test_case],
                       [TestCase::FINISHED,        test_case.name],
                       [TestCase::FINISHED_OBJECT, test_case],
                     ],
                     progress)
      end

      def test_add_failure_nested
        test_case = @tc_failure_error.new(:test_nested_failure)
        assert do
          test_case.passed?
        end

        result = TestResult.new
        faults = []
        result.add_listener(TestResult::FAULT) do |fault|
          faults << fault
        end
        test_case.run(result) do
        end
        fault_details = faults.collect do |fault|
          {
            :class     => fault.class,
            :message   => fault.message,
            :test_name => fault.test_name,
            :location  => normalize_location(fault.location),
          }
        end
        assert_equal([
                       {
                         :class     => Failure,
                         :message   => "nested",
                         :test_name => "test_nested_failure(TC_FailureError)",
                         :location  => [
                           "#{__FILE__}:0:in 'nested'",
                           "#{__FILE__}:0:in 'test_nested_failure'",
                           "#{__FILE__}:0:in '#{__method__}'",
                         ],
                       },
                     ],
                     fault_details)

        assert do
          not test_case.passed?
        end
      end

      def jruby?
        defined?(JRUBY_VERSION)
      end

      def rubinius?
        false # TODO
      end

      def cruby?
        (not jruby?) and (not rubinius?)
      end

      def test_add_error
        test_case = @tc_failure_error.new(:test_error)
        assert do
          test_case.passed?
        end

        result = TestResult.new
        faults = []
        result.add_listener(TestResult::FAULT) do |fault|
          faults << fault
        end
        test_case.run(result) do
        end
        fault_details = faults.collect do |fault|
          {
            :class     => fault.class,
            :message   => fault.message,
            :test_name => fault.test_name,
            :location  => normalize_location(fault.location),
          }
        end
        location = []
        location << "#{__FILE__}:0:in '/'" if cruby?
        location << "#{__FILE__}:0:in 'test_error'"
        location << "#{__FILE__}:0:in '#{__method__}'"
        assert_equal([
                       {
                         :class     => Error,
                         :message   => "ZeroDivisionError: divided by 0",
                         :test_name => "test_error(TC_FailureError)",
                         :location  => location,
                       },
                     ],
                     fault_details)

        assert do
          not test_case.passed?
        end
      end

      def test_no_tests
        suite = TestCase.suite
        check("Should have a test suite", suite.instance_of?(TestSuite))
        check("Should have one test", suite.size == 1)
        check("Should have the default test", suite.tests.first.name == "default_test(Test::Unit::TestCase)")

        result = TestResult.new
        suite.run(result) {}
        check("Should have had one test run", result.run_count == 1)
        check("Should have had one test failure", result.failure_count == 1)
        check("Should have had no errors", result.error_count == 0)
      end

      def test_suite
        tc = Class.new(TestCase) do
          def test_succeed
            assert_block {true}
          end
          def test_fail
            assert_block {false}
          end
          def test_error
            1/0
          end
          def dont_run
            assert_block {true}
          end
          def test_dont_run(argument)
            assert_block {true}
          end
          def test
            assert_block {true}
          end
        end

        suite = tc.suite
        check("Should have a test suite", suite.instance_of?(TestSuite))
        check("Should have three tests", suite.size == 3)

        result = TestResult.new
        suite.run(result) {}
        check("Should have had three test runs", result.run_count == 3)
        check("Should have had one test failure", result.failure_count == 1)
        check("Should have had one test error", result.error_count == 1)
      end

      def test_setup_teardown
        tc = Class.new(TestCase) do
          attr_reader(:setup_called, :teardown_called)
          def initialize(test)
            super(test)
            @setup_called = false
            @teardown_called = false
          end
          def setup
            @setup_called = true
          end
          def teardown
            @teardown_called = true
          end
          def test_succeed
            assert_block {true}
          end
          def test_fail
            assert_block {false}
          end
          def test_error
            raise "Error!"
          end
        end
        result = TestResult.new

        test = tc.new(:test_succeed)
        test.run(result) {}
        check("Should have called setup the correct number of times", test.setup_called)
        check("Should have called teardown the correct number of times", test.teardown_called)

        test = tc.new(:test_fail)
        test.run(result) {}
        check("Should have called setup the correct number of times", test.setup_called)
        check("Should have called teardown the correct number of times", test.teardown_called)

        test = tc.new(:test_error)
        test.run(result) {}
        check("Should have called setup the correct number of times", test.setup_called)
        check("Should have called teardown the correct number of times", test.teardown_called)

        check("Should have had two test runs", result.run_count == 3)
        check("Should have had a test failure", result.failure_count == 1)
        check("Should have had a test error", result.error_count == 1)
      end

      def test_assertion_failed_not_called
        tc = Class.new(TestCase) do
          def test_thing
            raise AssertionFailedError.new
          end
        end

        suite = tc.suite
        check("Should have one test", suite.size == 1)
        result = TestResult.new
        suite.run(result) {}
        check("Should have had one test run", result.run_count == 1)
        check("Should have had one assertion failure", result.failure_count == 1)
        check("Should not have any assertion errors but had #{result.error_count}", result.error_count == 0)
      end

      def test_equality
        tc1 = Class.new(TestCase) do
          def test_1
          end
          def test_2
          end
        end

        tc2 = Class.new(TestCase) do
          def test_1
          end
        end

        test1 = tc1.new('test_1')
        test2 = tc1.new('test_1')
        check("Should be equal", test1 == test2)
        check("Should be equal", test2 == test1)

        test1 = tc1.new('test_2')
        check("Should not be equal", test1 != test2)
        check("Should not be equal", test2 != test1)

        test2 = tc1.new('test_2')
        check("Should be equal", test1 == test2)
        check("Should be equal", test2 == test1)

        test1 = tc1.new('test_1')
        test2 = tc2.new('test_1')
        check("Should not be equal", test1 != test2)
        check("Should not be equal", test2 != test1)

        check("Should not be equal", test1 != Object.new)
        check("Should not be equal", Object.new != test1)
      end

      def test_re_raise_exception
        test_case = Class.new(TestCase) do
          def test_raise_interrupt
            raise Interrupt, "from test"
          end
        end

        test = test_case.new("test_raise_interrupt")
        begin
          test.run(TestResult.new) {}
          check("Should not be reached", false)
        rescue Exception
          check("Interrupt exception should be re-raised", $!.class == Interrupt)
        end
      end

      def test_timeout_error
        test_case = Class.new(TestCase) do
          def test_raise_timeout_error
            require "timeout"
            raise Timeout::Error
          end
        end

        test_suite = test_case.suite
        result = TestResult.new
        begin
          test_suite.run(result) {}
          check("Timeout::Error should be handled as error",
                result.error_count == 1)
        rescue Exception
          check("Timeout::Error should not be passed through: #{$!}", false)
        end
      end

      def test_interrupted
        test_case = Class.new(TestCase) do
          def test_fail
            flunk
          end

          def test_nothing
          end
        end

        failed_test = test_case.new(:test_fail)
        failed_test.run(TestResult.new) {}
        check("Should be interrupted", failed_test.interrupted?)

        success_test = test_case.new(:test_nothing)
        success_test.run(TestResult.new) {}
        check("Should not be interrupted", !success_test.interrupted?)
      end

      def test_inherited_test_should_be_ignored
        test_case = Class.new(TestCase) do
          def test_nothing
          end
        end

        sub_test_case = Class.new(test_case) do
          def test_fail
            flunk
          end
        end

        test = test_case.new("test_nothing")
        assert_predicate(test, :valid?)

        test = sub_test_case.new("test_fail")
        assert_predicate(test, :valid?)

        test = sub_test_case.new("test_nothing")
        assert_not_predicate(test, :valid?)
      end

      def test_mixin_test_should_not_be_ignored
        test_module = Module.new do
          def test_nothing
          end
        end

        test_case = Class.new(Test::Unit::TestCase) do
          include test_module

          def test_fail
            flunk
          end
        end

        assert_nothing_thrown do
          test_case.new("test_nothing")
        end

        assert_nothing_thrown do
          test_case.new("test_fail")
        end
      end

      def test_defined_order
        test_case = Class.new(Test::Unit::TestCase) do
          def test_z
          end

          def test_1
          end

          def test_a
          end
        end

        test_case.test_order = :defined
        assert_equal(["test_z", "test_1", "test_a"],
                     test_case.suite.tests.collect {|test| test.method_name})
      end

      def test_declarative_style
        test_case = Class.new(Test::Unit::TestCase) do
          test "declarative style test definition" do
          end

          test "include parenthesis" do
          end

          test "1 + 2 = 3" do
          end
        end

        test_case.test_order = :defined

        assert_equal(["test: declarative style test definition",
                      "test: include parenthesis",
                      "test: 1 + 2 = 3"],
                     test_case.suite.tests.collect {|test| test.method_name})

        assert_equal(["declarative style test definition",
                      "include parenthesis",
                      "1 + 2 = 3"],
                     test_case.suite.tests.collect {|test| test.description})
      end

      def test_test_mark
        test_case = Class.new(Test::Unit::TestCase) do
          test
          def my_test_method
          end
        end

        test_case.test_order = :defined

        assert_equal(["my_test_method"],
                     test_case.suite.tests.collect {|test| test.method_name})
      end

      def test_redefine_method
        test_case = Class.new(Test::Unit::TestCase) do
          self.test_order = :alphabetic

          def test_name
          end
          alias_method :test_name2, :test_name

          def test_name
          end
        end

        suite = test_case.suite
        assert_equal(["test_name", "test_name2"],
                     suite.tests.collect {|test| test.method_name})
        result = TestResult.new
        suite.run(result) {}
        assert_equal("2 tests, 0 assertions, 0 failures, " +
                     "0 errors, 0 pendings, 0 omissions, 1 notifications",
                     result.summary)
      end

      def test_data_driven_test
        test_case = Class.new(TestCase) do
          def test_with_data(data)
          end
        end

        test = test_case.new("test_with_data")
        assert_not_predicate(test, :valid?)
        test.assign_test_data("label1", :test_data1)
        assert_predicate(test, :valid?)
      end

      def test_data_driven_test_without_parameter
        test_case = Class.new(TestCase) do
          data("label" => "value")
          def test_without_parameter
            assert_equal("value", data)
          end
        end

        suite = test_case.suite
        assert_equal(["test_without_parameter"],
                     suite.tests.collect {|test| test.method_name})
        result = TestResult.new
        suite.run(result) {}
        assert_equal("1 tests, 1 assertions, 0 failures, " +
                     "0 errors, 0 pendings, 0 omissions, 0 notifications",
                     result.summary)
      end

      private
      def check(message, passed)
        add_assertion
        raise AssertionFailedError.new(message) unless passed
      end

      class TestTestDefined < self
        class TestNoQuery < self
          def test_no_test
            test_case = Class.new(TestCase) do
            end
            assert_false(test_case.test_defined?({}))
          end

          def test_have_def_style_test
            test_case = Class.new(TestCase) do
              def test_nothing
              end
            end
            assert_true(test_case.test_defined?({}))
          end

          def test_have_method_style_test
            test_case = Class.new(TestCase) do
              test "nothing" do
              end
            end
            assert_true(test_case.test_defined?({}))
          end
        end

        class TestPath < self
          class TestDefStyle < self
            def test_base_name
              test_case = Class.new(TestCase) do
                def test_nothing
                end
              end
              base_name = File.basename(__FILE__)
              assert_true(test_case.test_defined?(:path => base_name))
            end

            def test_absolute_path
              test_case = Class.new(TestCase) do
                def test_nothing
                end
              end
              assert_true(test_case.test_defined?(:path => __FILE__))
            end

            def test_not_match
              test_case = Class.new(TestCase) do
                def test_nothing
                end
              end
              assert_false(test_case.test_defined?(:path => "nonexistent.rb"))
            end
          end

          class TestMethodStyle < self
            def test_base_name
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
              end
              base_name = File.basename(__FILE__)
              assert_true(test_case.test_defined?(:path => base_name))
            end

            def test_absolute_path
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
              end
              assert_true(test_case.test_defined?(:path => __FILE__))
            end

            def test_not_match
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
              end
              assert_false(test_case.test_defined?(:path => "nonexistent.rb"))
            end
          end
        end

        class TestLine < self
          class TestDefStyle < self
            def test_before
              line_before = nil
              test_case = Class.new(TestCase) do
                line_before = __LINE__
                def test_nothing
                end
              end
              assert_false(test_case.test_defined?(:line => line_before))
            end

            def test_def
              line_def = nil
              test_case = Class.new(TestCase) do
                line_def = __LINE__; def test_nothing
                end
              end
              assert_true(test_case.test_defined?(:line => line_def))
            end

            def test_after
              line_after = nil
              test_case = Class.new(TestCase) do
                def test_nothing
                end
                line_after = __LINE__
              end
              assert_true(test_case.test_defined?(:line => line_after))
            end

            def test_child
              child_test_case = nil
              line_child = nil
              parent_test_case = Class.new(TestCase) do
                test "parent" do
                end

                child_test_case = Class.new(self) do
                  line_child = __LINE__; test "child" do
                  end
                end
              end
              assert_equal([
                             false,
                             true,
                           ],
                           [
                             parent_test_case.test_defined?(:line => line_child),
                             child_test_case.test_defined?(:line => line_child),
                           ])
            end
          end

          class TestMethodStyle < self
            def test_before
              line_before = nil
              test_case = Class.new(TestCase) do
                line_before = __LINE__
                test "nothing" do
                end
              end
              assert_false(test_case.test_defined?(:line => line_before))
            end

            def test_method
              line_method = nil
              test_case = Class.new(TestCase) do
                line_method = __LINE__; test "nothing" do
                end
              end
              assert_true(test_case.test_defined?(:line => line_method))
            end

            def test_after
              line_after = nil
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
                line_after = __LINE__
              end
              assert_true(test_case.test_defined?(:line => line_after))
            end

            def test_child
              child_test_case = nil
              line_child = nil
              parent_test_case = Class.new(TestCase) do
                test "parent" do
                end

                child_test_case = Class.new(self) do
                  line_child = __LINE__; test "child" do
                  end
                end
              end
              assert_equal([
                             false,
                             true,
                           ],
                           [
                             parent_test_case.test_defined?(:line => line_child),
                             child_test_case.test_defined?(:line => line_child),
                           ])
            end

            def test_with_setup
              line = nil
              test_case = Class.new(TestCase) do
                setup do
                end

                line = __LINE__; test "with setup" do
                end
              end
              assert do
                test_case.test_defined?(:line => line,
                                        :method_name => "test: with setup")
              end
            end
          end
        end

        class TestMethodName < self
          class TestDefStyle < self
            def test_match
              test_case = Class.new(TestCase) do
                def test_nothing
                end
              end
              query = {:method_name => "test_nothing"}
              assert_true(test_case.test_defined?(query))
            end

            def test_not_match
              test_case = Class.new(TestCase) do
                def test_nothing
                end
              end
              query = {:method_name => "test_nonexistent"}
              assert_false(test_case.test_defined?(query))
            end
          end

          class TestMethodStyle < self
            def test_match
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
              end
              query = {:method_name => "test: nothing"}
              assert_true(test_case.test_defined?(query))
            end

            def test_not_match
              test_case = Class.new(TestCase) do
                test "nothing" do
                end
              end
              query = {:method_name => "test: nonexistent"}
              assert_false(test_case.test_defined?(query))
            end
          end
        end

        class TestCombine < self
          class TestDefStyle < self
            def test_line_middle
              line_middle = nil
              test_case = Class.new(TestCase) do
                def test_before
                end
                line_middle = __LINE__
                def test_after
                end
              end
              query = {
                :path => __FILE__,
                :line => line_middle,
                :method_name => "test_before",
              }
              assert_true(test_case.test_defined?(query))
            end

            def test_line_after_def
              line_after_def = nil
              test_case = Class.new(TestCase) do
                def test_before
                end

                line_after_def = __LINE__; def test_after
                end
              end
              query = {
                :path => __FILE__,
                :line => line_after_def,
                :method_name => "test_before",
              }
              assert_false(test_case.test_defined?(query))
            end
          end

          class TestMethodStyle < self
            def test_line_middle
              line_middle = nil
              test_case = Class.new(TestCase) do
                test "before" do
                end
                line_middle = __LINE__
                test "after" do
                end
              end
              query = {
                :path => __FILE__,
                :line => line_middle,
                :method_name => "test: before",
              }
              assert_true(test_case.test_defined?(query))
            end

            def test_line_after_method
              line_after_method = nil
              test_case = Class.new(TestCase) do
                test "before" do
                end

                line_after_method = __LINE__; test "after" do
                end
              end
              query = {
                :path => __FILE__,
                :line => line_after_method,
                :method_name => "test: before",
              }
              assert_false(test_case.test_defined?(query))
            end
          end
        end
      end

      class TestSubTestCase < self
        class TestName < self
          def test_anonymous
            test_case = Class.new(TestCase)
            sub_test_case = test_case.sub_test_case("sub test case") do
            end
            assert_equal("sub test case", sub_test_case.name)
          end

          def test_named
            test_case = Class.new(TestCase)
            def test_case.name
              "ParentTestCase"
            end
            sub_test_case = test_case.sub_test_case("sub test case") do
            end
            assert_equal("ParentTestCase::sub test case", sub_test_case.name)
          end
        end

        def test_suite
          test_case = Class.new(TestCase)
          sub_test_case = test_case.sub_test_case("sub test case") do
            def test_nothing
            end
          end
          test_method_names = sub_test_case.suite.tests.collect do |test|
            test.method_name
          end
          assert_equal(["test_nothing"], test_method_names)
        end

        def test_duplicated_name
          test_case = Class.new(TestCase) do
            def test_nothing
            end
          end
          sub_test_case = test_case.sub_test_case("sub test case") do
            def test_nothing
            end
          end

          test_method_names = test_case.suite.tests.collect do |test|
            test.method_name
          end
          sub_test_method_names = sub_test_case.suite.tests.collect do |test|
            test.method_name
          end

          assert_equal([
                         ["test_nothing"],
                         ["test_nothing"],
                       ],
                       [
                         test_method_names,
                         sub_test_method_names,
                       ])
        end
      end

      class TestStartupShutdown < self
        class TestOrder < self
          module CallLogger
            def called
              @@called ||= []
            end
          end

          def call_order(test_case)
            test_case.called.clear
            test_suite = test_case.suite
            test_suite.run(TestResult.new) {}
            test_case.called
          end

          class TestNoInheritance < self
            def setup
              @test_case = Class.new(TestCase) do
                extend CallLogger

                class << self
                  def startup
                    called << :startup
                  end

                  def shutdown
                    called << :shutdown
                  end
                end

                def setup
                  self.class.called << :setup
                end

                def teardown
                  self.class.called << :teardown
                end

                def test1
                end

                def test2
                end
              end
            end

            def test_call_order
              assert_equal([
                             :startup,
                             :setup, :teardown,
                             :setup, :teardown,
                             :shutdown,
                           ],
                           call_order(@test_case))
            end
          end

          class TestInheritance < self
            def setup
              @original_descendants = TestCase::DESCENDANTS.dup
              TestCase::DESCENDANTS.clear

              @parent_test_case = Class.new(TestCase) do
                extend CallLogger

                self.test_order = :alphabetic

                class << self
                  def startup
                    called << :startup_parent
                  end

                  def shutdown
                    called << :shutdown_parent
                  end
                end

                def setup
                  self.class.called << :setup_parent
                end

                def teardown
                  self.class.called << :teardown_parent
                end

                def test1_parent
                  self.class.called << :test1_parent
                end

                def test2_parent
                  self.class.called << :test2_parent
                end
              end

              @child_test_case = Class.new(@parent_test_case) do
                class << self
                  def startup
                    called << :startup_child
                  end

                  def shutdown
                    called << :shutdown_child
                  end
                end

                def setup
                  self.class.called << :setup_child
                end

                def teardown
                  self.class.called << :teardown_child
                end

                def test1_child
                  self.class.called << :test1_child
                end

                def test2_child
                  self.class.called << :test2_child
                end
              end
            end

            def teardown
              TestCase::DESCENDANTS.replace(@original_descendants)
            end

            def test_call_order
              collector = Collector::Descendant.new
              test_suite = collector.collect
              test_suite.run(TestResult.new) {}
              called = @parent_test_case.called
              assert_equal([
                             :startup_parent,
                             :setup_parent, :test1_parent, :teardown_parent,
                             :setup_parent, :test2_parent, :teardown_parent,
                             :startup_child,
                             :setup_child, :test1_child, :teardown_child,
                             :setup_child, :test2_child, :teardown_child,
                             :shutdown_child,
                             :shutdown_parent,
                           ],
                           called)
            end
          end
        end

        class TestError < self
          def run_test_case(test_case)
            test_suite = test_case.suite
            result = TestResult.new
            test_suite.run(result) {}
            result
          end

          def error_count(test_case)
            run_test_case(test_case).error_count
          end

          def test_on_startup
            test_case = Class.new(TestCase) do
              class << self
                def startup
                  raise "from startup"
                end
              end

              def test_nothing
              end
            end

            assert_equal(1, error_count(test_case))
          end

          def test_pass_through_on_startup
            test_case = Class.new(TestCase) do
              class << self
                def startup
                  raise Interrupt, "from startup"
                end
              end

              def test_nothing
              end
            end

            assert_raise(Interrupt) do
              run_test_case(test_case)
            end
          end

          def test_on_shutdown
            test_case = Class.new(TestCase) do
              class << self
                def shutdown
                  raise "from shutdown"
                end
              end

              def test_nothing
              end
            end

            assert_equal(1, error_count(test_case))
          end

          def test_pass_through_on_shutdown
            test_case = Class.new(TestCase) do
              class << self
                def shutdown
                  raise Interrupt, "from shutdown"
                end
              end

              def test_nothing
              end
            end

            assert_raise(Interrupt) do
              run_test_case(test_case)
            end
          end

          def test_pass_through_in_test
            test_case = Class.new(TestCase) do
              @called = []
              class << self
                def called
                  @called
                end

                def startup
                  @called << :startup
                end

                def shutdown
                  @called << :shutdown
                end
              end

              def test_error
                raise Interrupt, "from test"
              end
            end

            assert_raise(Interrupt) do
              run_test_case(test_case)
            end
            assert_equal([:startup, :shutdown],
                         test_case.called)
          end

          class TestName < self
            def test_no_data
              test_case = Class.new(TestCase) do
                class << self
                  def name
                    "TestCase"
                  end
                end

                def test_nothing
                end
              end

              test = test_case.new("test_nothing")
              assert_equal("test_nothing(TestCase)",
                           test.name)
            end

            def test_data
              test_case = Class.new(TestCase) do
                class << self
                  def name
                    "TestCase"
                  end
                end

                def test_nothing
                end
              end

              test = test_case.new("test_nothing")
              test.assign_test_data("(nil)", nil)
              assert_equal("test_nothing[(nil)](TestCase)",
                           test.name)
            end
          end

          class TestLocalName < self
            def test_no_data
              test_case = Class.new(TestCase) do
                class << self
                  def name
                    "TestCase"
                  end
                end

                def test_nothing
                end
              end

              test = test_case.new("test_nothing")
              assert_equal("test_nothing",
                           test.local_name)
            end

            def test_data
              test_case = Class.new(TestCase) do
                class << self
                  def name
                    "TestCase"
                  end
                end

                def test_nothing
                end
              end

              test = test_case.new("test_nothing")
              test.assign_test_data("(nil)", nil)
              assert_equal("test_nothing[(nil)]",
                           test.local_name)
            end
          end
        end
      end
    end
  end
end
test-unit-3.6.2/test/test-test-result.rb000066400000000000000000000061121456346657200202540ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/testcase'
require 'test/unit/testresult'

module Test
  module Unit
    class TC_TestResult < TestCase
      def setup
        @my_result = TestResult.new
        @my_result.add_assertion()
        @failure = "failure"
        @my_result.add_failure(@failure)
        @error = "error"
        @my_result.add_error(@error)
      end

      def test_result_changed_notification
        called1 = false
        @my_result.add_listener(TestResult::CHANGED) do |result|
          assert_equal(@my_result, result)
          called1 = true
        end
        @my_result.add_assertion
        assert_true(called1)

        called1, called2 = false, false
        @my_result.add_listener(TestResult::CHANGED) do |result|
          assert_equal(@my_result, result)
          called2 = true
        end
        @my_result.add_assertion
        assert_equal([true, true], [called1, called2])

        called1, called2 = false, false
        @my_result.add_failure("")
        assert_equal([true, true], [called1, called2])

        called1, called2 = false, false
        @my_result.add_error("")
        assert_equal([true, true], [called1, called2])

        called1, called2 = false, false
        @my_result.add_run
        assert_equal([true, true], [called1, called2])
      end

      def test_fault_notification
        called1 = false
        fault = "fault"
        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
          assert_equal(fault, passed_fault)
          called1 = true
        end

        @my_result.add_assertion
        assert_false(called1)

        @my_result.add_failure(fault)
        assert_true(called1)

        called1, called2 = false, false
        @my_result.add_listener(TestResult::FAULT) do |passed_fault|
          assert_equal(fault, passed_fault)
          called2 = true
        end

        @my_result.add_assertion
        assert_equal([false, false], [called1, called2])

        called1, called2 = false, false
        @my_result.add_failure(fault)
        assert_equal([true, true], [called1, called2])

        called1, called2 = false, false
        @my_result.add_error(fault)
        assert_equal([true, true], [called1, called2])

        called1, called2 = false, false
        @my_result.add_run
        assert_equal([false, false], [called1, called2])
      end

      def test_passed?
        result = TestResult.new
        assert_true(result.passed?)

        result.add_assertion
        assert_true(result.passed?)

        result.add_run
        assert_true(result.passed?)

        result.add_failure("")
        assert_false(result.passed?)

        result = TestResult.new
        result.add_error("")
        assert_false(result.passed?)
      end

      def test_faults
        assert_equal([@failure, @error], @my_result.faults)

        notification = "notification"
        @my_result.add_notification(notification)
        assert_equal([@failure, @error, notification], @my_result.faults)
      end
    end
  end
end
test-unit-3.6.2/test/test-test-suite-creator.rb000066400000000000000000000044041456346657200215260ustar00rootroot00000000000000require "test/unit"

module Test
  module Unit
    class TestTestSuiteCreator < TestCase
      def collect_test_names(test_case)
        creator = TestSuiteCreator.new(test_case)
        creator.send(:collect_test_names)
      end

      class TestStandalone < self
        def setup
          @test_case = Class.new(TestCase) do
            def test_in_test_case
            end
          end
        end

        def test_collect_test_names
          assert_equal(["test_in_test_case"], collect_test_names(@test_case))
        end
      end

      class TestInherited < self
        def setup
          @parent_test_case = Class.new(TestCase) do
            def test_in_parent
            end
          end

          @child_test_case = Class.new(@parent_test_case) do
            def test_in_child
            end
          end
        end

        def test_collect_test_names
          assert_equal(["test_in_child"], collect_test_names(@child_test_case))
        end
      end

      class TestModule < self
        def setup
          test_module = Module.new do
            def test_in_module
            end
          end

          @test_case = Class.new(TestCase) do
            include test_module

            def test_in_test_case
            end
          end
        end

        def test_collect_test_names
          assert_equal(["test_in_module", "test_in_test_case"].sort,
                       collect_test_names(@test_case).sort)
        end
      end

      class TestInheritedModule < self
        def setup
          parent_test_module = Module.new do
            def test_in_module_in_parent
            end
          end

          child_test_module = Module.new do
            def test_in_module_in_child
            end
          end

          @parent_test_case = Class.new(TestCase) do
            include parent_test_module

            def test_in_parent
            end
          end

          @child_test_case = Class.new(@parent_test_case) do
            include child_test_module

            def test_in_child
            end
          end
        end

        def test_collect_test_names
          assert_equal(["test_in_child", "test_in_module_in_child"].sort,
                       collect_test_names(@child_test_case).sort)
        end
      end
    end
  end
end
test-unit-3.6.2/test/test-test-suite.rb000066400000000000000000000112661456346657200200750ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2003 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'

module Test
  module Unit
    class TestTestSuite < TestCase
      def setup
        @testcase1 = Class.new(TestCase) do
          def test_succeed1
            assert_block { true }
          end
          def test_fail
            assert_block { false }
          end
        end

        @testcase2 = Class.new(TestCase) do
          def test_succeed2
            assert_block { true }
          end
          def test_error
            raise
          end
        end
      end

      def test_add
        s = TestSuite.new
        assert_equal(s, s << self.class.new("test_add"))
      end

      def test_delete
        s = TestSuite.new
        t1 = self.class.new("test_delete")
        s << t1
        t2 = self.class.new("test_add")
        s << t2
        assert_equal(t1, s.delete(t1))
        assert_nil(s.delete(t1))
        assert_equal(TestSuite.new << t2, s)
      end

      def test_delete_tests
        suite = TestSuite.new
        test1 = self.class.new("test_delete_1")
        suite << test1
        test2 = self.class.new("test_delete_2")
        suite << test2
        test3 = self.class.new("test_add")
        suite << test3
        suite.delete_tests([test1, test2])
        assert_equal(1, suite.size)
        assert_equal(TestSuite.new << test3, suite)
      end

      def test_size
        suite = TestSuite.new
        suite2 = TestSuite.new
        suite2 << self.class.new("test_size")
        suite << suite2
        suite << self.class.new("test_size")
        assert_equal(2, suite.size, "The count should be correct")
      end

      def test_run
        progress = []
        @testcase1.test_order = :alphabetic
        suite = @testcase1.suite
        tests = suite.tests.dup
        result = TestResult.new
        suite.run(result) { |*values| progress << values }

        assert_equal(2, result.run_count, "Should have had four test runs")
        assert_equal(1, result.failure_count, "Should have had one test failure")
        assert_equal(0, result.error_count, "Should have had one test error")
        assert_equal([[TestSuite::STARTED, suite.name],
                      [TestSuite::STARTED_OBJECT, suite],
                      [TestCase::STARTED, "test_fail(#{suite.name})"],
                      [TestCase::STARTED_OBJECT, tests[0]],
                      [TestCase::FINISHED, "test_fail(#{suite.name})"],
                      [TestCase::FINISHED_OBJECT, tests[0]],
                      [TestCase::STARTED, "test_succeed1(#{suite.name})"],
                      [TestCase::STARTED_OBJECT, tests[1]],
                      [TestCase::FINISHED, "test_succeed1(#{suite.name})"],
                      [TestCase::FINISHED_OBJECT, tests[1]],
                      [TestSuite::FINISHED, suite.name],
                      [TestSuite::FINISHED_OBJECT, suite]],
                     progress, "Should have had the correct progress")

        suite = TestSuite.new
        suite << @testcase1.suite
        suite << @testcase2.suite
        result = TestResult.new
        progress = []
        suite.run(result) { |*values| progress << values }

        assert_equal(4, result.run_count, "Should have had four test runs")
        assert_equal(1, result.failure_count, "Should have had one test failure")
        assert_equal(1, result.error_count, "Should have had one test error")
        assert_equal(28, progress.size,
                     "Should have had the correct number of progress calls")
      end

      def test_empty?
        assert(TestSuite.new.empty?, "A new test suite should be empty?")
        assert(!@testcase2.suite.empty?, "A test suite with tests should not be empty")
      end

      def test_equality
        suite1 = TestSuite.new
        suite2 = TestSuite.new
        assert_equal(suite1, suite2)
        assert_equal(suite2, suite1)

        suite1 = TestSuite.new('name')
        assert_not_equal(suite1, suite2)
        assert_not_equal(suite2, suite1)

        suite2 = TestSuite.new('name')
        assert_equal(suite1, suite2)
        assert_equal(suite2, suite1)

        suite1 << 'test'
        assert_not_equal(suite1, suite2)
        assert_not_equal(suite2, suite1)

        suite2 << 'test'
        assert_equal(suite1, suite2)
        assert_equal(suite2, suite1)

        suite2 = Object.new
        class << suite2
          def name
            'name'
          end
          def tests
            ['test']
          end
        end
        assert_not_equal(suite1, suite2)
        assert_not_equal(suite2, suite1)

        assert_not_equal(suite1, Object.new)
        assert_not_equal(Object.new, suite1)
      end
    end
  end
end
test-unit-3.6.2/test/testunit-test-util.rb000066400000000000000000000012501456346657200206110ustar00rootroot00000000000000require "objspace"
require "tempfile"
require "bigdecimal"

module TestUnitTestUtil
  private
  def jruby?
    RUBY_PLATFORM == "java"
  end

  def jruby_only_test
    if jruby?
      require "java"
    else
      omit("test for JRuby")
    end
  end

  def assert_fault_messages(expected, faults)
    assert_equal(expected, faults.collect {|fault| fault.message})
  end

  def _run_test(test_case, name)
    result = Test::Unit::TestResult.new
    test = test_case.new(name)
    yield(test) if block_given?
    test.run(result) {}
    result
  end

  def fixture_file_path(file_name)
    base_dir = File.dirname(__FILE__)
    File.join(base_dir, "fixtures", file_name)
  end
end
test-unit-3.6.2/test/ui/000077500000000000000000000000001456346657200150745ustar00rootroot00000000000000test-unit-3.6.2/test/ui/test_testrunmediator.rb000066400000000000000000000010601456346657200217060ustar00rootroot00000000000000require 'test/unit/ui/testrunnermediator'

class TestUnitUIMediator < Test::Unit::TestCase
  def test_run_suite_with_interrupt_exception
    test_case = Class.new(Test::Unit::TestCase) do
      def test_raise_interrupt
        raise Interrupt, "from test"
      end
    end
    mediator = Test::Unit::UI::TestRunnerMediator.new(test_case.suite)
    finished = false
    mediator.add_listener(Test::Unit::UI::TestRunnerMediator::FINISHED) do
      finished = true
    end
    assert_raise(Interrupt) do
      mediator.run
    end
    assert(finished)
  end
end
test-unit-3.6.2/test/util/000077500000000000000000000000001456346657200154345ustar00rootroot00000000000000test-unit-3.6.2/test/util/test-method-owner-finder.rb000066400000000000000000000020221456346657200226070ustar00rootroot00000000000000require 'test/unit'

require 'test/unit/util/method-owner-finder'

class TestUnitMethodOwnerFinder < Test::Unit::TestCase
  def test_find
    assert_equal(Exception, find(RuntimeError.new, :inspect))
    assert_equal(Exception, find(Exception.new, :inspect))

    anonymous_class = Class.new do
    end
    assert_equal(Kernel, find(anonymous_class.new, :inspect))

    anonymous_parent_class = Class.new do
      def inspect
        super + " by anonymous parent class"
      end
    end
    anonymous_sub_class = Class.new(anonymous_parent_class) do
    end
    assert_equal(anonymous_parent_class, find(anonymous_sub_class.new, :inspect))

    anonymous_module = Module.new do
      def inspect
        super + " by anonymous module"
      end
    end
    anonymous_include_class = Class.new do
      include anonymous_module
    end
    assert_equal(anonymous_module, find(anonymous_include_class.new, :inspect))
  end

  private
  def find(object, method_name)
    Test::Unit::Util::MethodOwnerFinder.find(object, method_name)
  end
end
test-unit-3.6.2/test/util/test-output.rb000066400000000000000000000004151456346657200202760ustar00rootroot00000000000000require 'test/unit'

class TestUnitOutput < Test::Unit::TestCase
  def test_capture_output
    assert_equal(["stdout\n", "stderr\n"],
                 capture_output do
                   puts("stdout")
                   warn("stderr")
                 end)
  end
end
test-unit-3.6.2/test/util/test_backtracefilter.rb000066400000000000000000000042751456346657200221550ustar00rootroot00000000000000require 'test/unit'

require 'test/unit/util/backtracefilter'

module Test::Unit::Util
  class TestBacktraceFilter < Test::Unit::TestCase
    include BacktraceFilter
    
    def test_filter_backtrace
      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
        %q{tc_thing.rb:4:in 'a'},
        %q{tc_thing.rb:4:in 'test_stuff'},
        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
        %q{C:\some\old\path\test\unit.rb:44:in 'run'},
        %q{tc_thing.rb:3}]
      assert_equal(backtrace[1..2], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")

      backtrace = [%q{tc_thing.rb:4:in 'a'},
        %q{tc_thing.rb:4:in 'test_stuff'},
        %q{tc_thing.rb:3}]
      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Shouldn't filter too much")

      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
        %q{tc_thing.rb:4:in 'a'},
        %q{tc_thing.rb:4:in 'test_stuff'},
        %q{tc_thing.rb:3}]
      assert_equal(backtrace[1..3], filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
      
      backtrace = [%q{C:\some\old\path/test/unit/assertions.rb:44:in 'assert'},
        %q{C:\some\old\path/test/unit/testcase.rb:44:in 'send'},
        %q{C:\some\old\path\test\unit\testcase.rb:44:in 'run'},
        %q{C:\some\old\path\test\unit.rb:44:in 'run'}]
      assert_equal(backtrace, filter_backtrace(backtrace, %q{C:\some\old\path\test\unit}), "Should filter out all TestUnit-specific lines")
    end

    def test_nil_backtrace
      assert_equal(["No backtrace"], filter_backtrace(nil))
    end

    def test_power_assert_backtrace
      omit('test for power_assert') unless defined?(PowerAssert)
      blk = Proc.new {caller.find {|i| /power_assert.*in [`'](?:PowerAssert\.)?start'/ =~ i}}
      PowerAssert.start(blk) do |pa|
        backtrace = [pa.yield,
          %q{tc_thing.rb:4:in 'a'},
          %q{tc_thing.rb:4:in 'test_stuff'}]
        assert_equal(backtrace[1..2], filter_backtrace(backtrace))
      end
    end
  end
end
test-unit-3.6.2/test/util/test_observable.rb000066400000000000000000000076531456346657200211570ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit/util/observable'

module Test
  module Unit
    module Util
      class TC_Observable < TestCase
      
        class TF_Observable
          include Observable
        end
        
        def setup
          @observable = TF_Observable.new
        end
        
        def test_simple_observation
          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
            @observable.add_listener(:property, "a")
          end
      
          heard = false
          callback = proc { heard = true }
          assert_equal("a", @observable.add_listener(:property, "a", &callback), "add_listener should return the listener that was added")
      
          count = 0
          @observable.instance_eval do
            count = notify_listeners(:property)
          end
          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
          assert(heard, "Should have heard the property changed")
      
          heard = false
          assert_equal(callback, @observable.remove_listener(:property, "a"), "remove_listener should return the callback")
          
          count = 1
          @observable.instance_eval do
            count = notify_listeners(:property)
          end
          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
          assert(!heard, "Should not have heard the property change")
        end
        
        def test_value_observation
          value = nil
          @observable.add_listener(:property, "a") do |passed_value|
            value = passed_value
          end
          count = 0
          @observable.instance_eval do
            count = notify_listeners(:property, "stuff")
          end
          assert_equal(1, count, "Should have update the correct number of listeners")
          assert_equal("stuff", value, "Should have received the value as an argument to the listener")
        end
        
        def test_multiple_value_observation
          values = []
          @observable.add_listener(:property, "a") do |first_value, second_value|
            values = [first_value, second_value]
          end
          count = 0
          @observable.instance_eval do
            count = notify_listeners(:property, "stuff", "more stuff")
          end
          assert_equal(1, count, "Should have update the correct number of listeners")
          assert_equal(["stuff", "more stuff"], values, "Should have received the value as an argument to the listener")
        end
        
        def test_add_remove_with_default_listener
          assert_raises(ArgumentError, "add_listener should throw an exception if no callback is supplied") do
            @observable.add_listener(:property)
          end
      
          heard = false
          callback = proc { heard = true }
          assert_equal(callback, @observable.add_listener(:property, &callback), "add_listener should return the listener that was added")
      
          count = 0
          @observable.instance_eval do
            count = notify_listeners(:property)
          end
          assert_equal(1, count, "notify_listeners should have returned the number of listeners that were notified")
          assert(heard, "Should have heard the property changed")
      
          heard = false
          assert_equal(callback, @observable.remove_listener(:property, callback), "remove_listener should return the callback")
      
          count = 1
          @observable.instance_eval do
            count = notify_listeners(:property)
          end
          assert_equal(0, count, "notify_listeners should have returned the number of listeners that were notified")
          assert(!heard, "Should not have heard the property change")
        end
      end
    end
  end
end
test-unit-3.6.2/test/util/test_procwrapper.rb000066400000000000000000000023711456346657200213670ustar00rootroot00000000000000# Author:: Nathaniel Talbott.
# Copyright:: Copyright (c) 2000-2002 Nathaniel Talbott. All rights reserved.
# License:: Ruby license.

require 'test/unit'
require 'test/unit/util/procwrapper'

module Test
  module Unit
    module Util
      class TC_ProcWrapper < TestCase
        def munge_proc(&a_proc)
          return a_proc
        end
        def setup
          @original = proc {}
          @munged = munge_proc(&@original)
          @wrapped_original = ProcWrapper.new(@original)
          @wrapped_munged = ProcWrapper.new(@munged)
        end
        def test_wrapping
          assert_same(@original, @wrapped_original.to_proc, "The wrapper should return what was wrapped")
        end
        def test_hashing
      
          assert_equal(@wrapped_original.hash, @wrapped_munged.hash, "The original and munged should have the same hash when wrapped")
          assert_equal(@wrapped_original, @wrapped_munged, "The wrappers should be equivalent")
          
          a_hash = {@wrapped_original => @original}
          assert(a_hash[@wrapped_original], "Should be able to access the wrapper in the hash")
          assert_equal(a_hash[@wrapped_original], @original, "Should be able to access the wrapper in the hash")
        end
      end
    end
  end
end