Japanized Perl Resources Project[凍結]

[perldocjp-cvs 1840] CVS update: docs/modules/Test-Simple-0.99/lib/Test

ktats****@users***** ktats****@users*****
2013年 11月 10日 (日) 14:17:31 JST

• 前の記事 [perldocjp-cvs 1836] CVS update: docs/modules/Test-Simple-0.99/lib/Test
• 次の記事 [perldocjp-cvs 1837] CVS update: docs/modules/Test-Simple-0.99/lib/Test
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]

Index: docs/modules/Test-Simple-0.99/lib/Test/More.pod
diff -u /dev/null docs/modules/Test-Simple-0.99/lib/Test/More.pod:1.1
--- /dev/null	Sun Nov 10 14:17:31 2013
+++ docs/modules/Test-Simple-0.99/lib/Test/More.pod	Sun Nov 10 14:17:31 2013
@@ -0,0 +1,2372 @@
+=encoding utf8
+
+=head1 NAME
+
+=begin original
+
+Test::More - yet another framework for writing test scripts
+
+=end original
+
+Test::More - テストを書くためのもう一つのフレームワーク
+
+=head1 SYNOPSIS
+
+  use Test::More tests => 23;
+  # or
+  use Test::More skip_all => $reason;
+  # or
+  use Test::More;   # see done_testing()
+
+  require_ok( 'Some::Module' );
+
+  # 「ok」と示すためのさまざまな方法
+  ok($got eq $expected, $test_name);
+
+  is  ($got, $expected, $test_name);
+  isnt($got, $expected, $test_name);
+
+  # STDERR に出力するよりも  "# here's what went wrong\n"
+  diag("here's what went wrong");
+
+  like  ($got, qr/expected/, $test_name);
+  unlike($got, qr/expected/, $test_name);
+
+  cmp_ok($got, '==', $expected, $test_name);
+
+  is_deeply($got_complex_structure, $expected_complex_structure, $test_name);
+
+  SKIP: {
+      skip $why, $how_many unless $have_some_feature;
+
+      ok( foo(),       $test_name );
+      is( foo(42), 23, $test_name );
+  };
+
+  TODO: {
+      local $TODO = $why;
+
+      ok( foo(),       $test_name );
+      is( foo(42), 23, $test_name );
+  };
+
+  can_ok($module, @methods);
+  isa_ok($object, $class);
+
+  pass($test_name);
+  fail($test_name);
+
+  BAIL_OUT($why);
+
+  # UNIMPLEMENTED!!!
+
+  my @status = Test::More::status;
+
+=head1 DESCRIPTION
+
+=begin original
+
+B<STOP!> If you're just getting started writing tests, have a look at
+L<Test::Simple> first.  This is a drop in replacement for Test::Simple
+which you can switch to once you get the hang of basic testing.
+
+=end original
+
+B<待った!>もし、今初めて、テストを書こうとしているのなら、Test::Simpleをまず見てください。
+Test::Moreは、基本的なテストのコツを得て、置き換え可能なTest::Simpleの差込式の置換です。
+
+=begin original
+
+The purpose of this module is to provide a wide range of testing
+utilities.  Various ways to say "ok" with better diagnostics,
+facilities to skip tests, test future features and compare complicated
+data structures.  While you can do almost anything with a simple
+C<ok()> function, it doesn't provide good diagnostic output.
+
+=end original
+
+このモジュールの目的は、大幅なテストユーティリティを提供することです。
+よりよい診断で「ok」と示す方法を用意したり、テストを簡単にスキップしたり、
+将来的な実装をテストしたり、複雑なデータ構造を比較したりする様々な機能があります。
+単純なC<ok()>関数でほとんど全てのことが出来ますが、C<ok()>関数は、良い診断出力を提供しません。
+
+=head2 I love it when a plan comes together
+
+(計画が一緒に来るなら、それを大事にする)
+
+=begin original
+
+Before anything else, you need a testing plan.  This basically declares
+how many tests your script is going to run to protect against premature
+failure.
+
+=end original
+
+他の何より前に、テストの計画が必要です。 スクリプトが行おうとしているテストが
+いくつであるかというこの基本的な宣言は、原始的な失敗に対する保護になります。
+
+=begin original
+
+The preferred way to do this is to declare a plan when you C<use Test::More>.
+
+=end original
+
+この保護を行う好ましい方法は、C<use Test::More> を書く時に、計画を宣言することです。
+
+  use Test::More tests => 23;
+
+=begin original
+
+There are cases when you will not know beforehand how many tests your
+script is going to run.  In this case, you can declare your tests at
+the end.
+
+=end original
+
+scriptが行おうとしているテストがいくつあるかを事前に知らないような、まれなケースがあります。
+こういうケースでは、最後にテストを宣言することができます。
+
+
+  use Test::More;
+  
+  ... run your tests ...
+  
+  done_testing( $number_of_tests_run );
+
+=begin original
+
+Sometimes you really don't know how many tests were run, or it's too
+difficult to calculate.  In which case you can leave off
+$number_of_tests_run.
+
+=end original
+
+いくつのテストが実行されるか本当に分からない時や、計算するのが大変な時に使えます。
+そのようなケースでは、$number_of_tests_run を省くことができます。
+
+=begin original
+
+In some cases, you'll want to completely skip an entire testing script.
+
+=end original
+
+いくつかのケースでは、あるテストscript全てを完全にスキップしたいでしょう。
+
+  use Test::More skip_all => $skip_reason;
+
+=begin original
+
+Your script will declare a skip with the reason why you skipped and
+exit immediately with a zero (success).  See L<Test::Harness> for
+details.
+
+=end original
+
+scriptが、なぜスキップするのかの理由を宣言すると、即座に0(成功)で終了します。
+詳細についてはL<Test::Harness>をみてください。
+
+=begin original
+
+If you want to control what functions Test::More will export, you
+have to use the 'import' option.  For example, to import everything
+but 'fail', you'd do:
+
+=end original
+
+Test::Moreがエクスポートする関数をコントロールしたければ、
+'import'オプションを使う必要があります。
+たとえば、'fail'を除いて、全てをインポートしたいなら、次のようにします：
+
+  use Test::More tests => 23, import => ['!fail'];
+
+=begin original
+
+Alternatively, you can use the plan() function.  Useful for when you
+have to calculate the number of tests.
+
+=end original
+
+代わりに、plan() 関数を使うことが出来ます。
+テストの数を計算しなければならないなら、有益です。
+
+  use Test::More;
+  plan tests => keys %Stuff * 3;
+
+=begin original
+
+or for deciding between running the tests at all:
+
+=end original
+
+または、テストを走らせている間に決めるためには：
+
+  use Test::More;
+  if( $^O eq 'MacOS' ) {
+      plan skip_all => 'Test irrelevant on MacOS';
+  }
+  else {
+      plan tests => 42;
+  }
+
+=cut
+
+=over 4
+
+=item B<done_testing>
+
+    done_testing();
+    done_testing($number_of_tests);
+
+=begin original
+
+If you don't know how many tests you're going to run, you can issue
+the plan when you're done running tests.
+
+=end original
+
+実行しようとしているテストがいくつかわからない場合、テストの実行を終えたときに
+計画を発表することができます。
+
+=begin original
+
+$number_of_tests is the same as plan(), it's the number of tests you
+expected to run.  You can omit this, in which case the number of tests
+you ran doesn't matter, just the fact that your tests ran to
+conclusion.
+
+=end original
+
+$number_of_tests は、plan()と同じです。実行しようとしているテストの数です。
+これを省略することもできます。その場合、テストの数は問題にしません。
+最後までテストが実行されたかを問題にします。
+
+=begin original
+
+This is safer than and replaces the "no_plan" plan.
+
+=end original
+
+"no_plan"な計画より安全で、"no_plan"を置き換えるものです。
+
+=back
+
+
+=cut
+
+=head2 Test names
+
+(テストの名前)
+
+=begin original
+
+By convention, each test is assigned a number in order.  This is
+largely done automatically for you.  However, it's often very useful to
+assign a name to each test.  Which would you rather see:
+
+=end original
+
+便宜のために、それぞれのテストは、順番に番号が割り振られています。
+これは、主に自動的に行われます。ですが、テストに名前を割り当てると、
+とても有益なことがよくあります。どちらがよいでしょうか:
+
+  ok 4
+  not ok 5
+  ok 6
+
+=begin original
+
+or
+
+=end original
+
+というのと、
+
+  ok 4 - basic multi-variable
+  not ok 5 - simple exponential
+  ok 6 - force == mass * acceleration
+
+=begin original
+
+The later gives you some idea of what failed.  It also makes it easier
+to find the test in your script, simply search for "simple
+exponential".
+
+=end original
+
+後者は、何が失敗したかの手がかりを与えてくれます。
+また、script中のテストを見つけやすくなり、「簡単な指数関数」を楽に探せます。
+
+=begin original
+
+All test functions take a name argument.  It's optional, but highly
+suggested that you use it.
+
+=end original
+
+全てのテストの関数は、名前を引数にとります。名前の引数は、オプショナルではありますが、
+使うことが強く推奨されています。
+
+=head2 I'm ok, you're not ok.
+
+=begin original
+
+The basic purpose of this module is to print out either "ok #" or "not
+ok #" depending on if a given test succeeded or failed.  Everything
+else is just gravy.
+
+=end original
+
+このモジュールの基本的な目的は、与えたテストが、失敗したか、成功したかで、
+「ok 番号」か、「not ok 番号」のどちらかを出力することです。他の全ては、ただのおまけです。
+
+=begin original
+
+All of the following print "ok" or "not ok" depending on if the test
+succeeded or failed.  They all also return true or false,
+respectively.
+
+=end original
+
+この下に書いているものは全て、テストが成功したか失敗したかどうかによって、「ok」か「not ok」を表示します。
+それらは、全て、それぞれ真か偽を返します。
+
+=over 4
+
+=item B<ok>
+
+  ok($got eq $expected, $test_name);
+
+=begin original
+
+This simply evaluates any expression (C<$got eq $expected> is just a
+simple example) and uses that to determine if the test succeeded or
+failed.  A true expression passes, a false one fails.  Very simple.
+
+=end original
+
+これは単純に、どんな式も評価します(C<$got eq $expected>はただの簡単な例です)。
+そして、テストが成功したかどうかを決めるのに使います。
+真の式は合格し、偽の式は失敗です。とても簡単です。
+
+=begin original
+
+For example:
+
+=end original
+
+たとえば:
+
+    ok( $exp{9} == 81,                   'simple exponential' );
+    ok( Film->can('db_Main'),            'set_db()' );
+    ok( $p->tests == 4,                  'saw tests' );
+    ok( !grep(!defined $_, @items),      'all items defined' );
+
+
+=begin original
+
+(Mnemonic:  "This is ok.")
+
+=end original
+
+(覚えかた:  "This is ok.")
+
+=begin original
+
+$test_name is a very short description of the test that will be printed
+out.  It makes it very easy to find a test in your script when it fails
+and gives others an idea of your intentions.  $test_name is optional,
+but we B<very> strongly encourage its use.
+
+=end original
+
+C<$test_name>は、とても短いテストの説明で、実行時に出力されます。
+$test_nameは、テストが失敗した場合に、script中のテストをとても見つけやすくします。
+それに、他の人に、あなたの意図する考えを伝えます。$test_nameは、は、オプショナルですが、
+使うことが強く勧められています。
+
+=begin original
+
+Should an ok() fail, it will produce some diagnostics:
+
+=end original
+
+万一、ok()が失敗した場合、ちょっとした診断を提供します:
+
+    not ok 18 - sufficient mucus
+    #   Failed test 'sufficient mucus'
+    #   in foo.t at line 42.
+
+=begin original
+
+This is the same as Test::Simple's ok() routine.
+
+=end original
+
+これは、Test::SimpleのC<ok()> ルーチンと同じです。
+
+=item B<is>
+
+=item B<isnt>
+
+  is  ( $got, $expected, $test_name );
+  isnt( $got, $expected, $test_name );
+
+=begin original
+
+Similar to ok(), is() and isnt() compare their two arguments
+with C<eq> and C<ne> respectively and use the result of that to
+determine if the test succeeded or failed.  So these:
+
+=end original
+
+ok() と is() と isnt() の類似点は、二つの引数をそれぞれC<eq> と C<ne>で比較し、
+その結果を使って、テストが成功したか、失敗したかを決めることです。それで、これらは：
+
+    # Is the ultimate answer 42?
+    is( ultimate_answer(), 42,          "Meaning of Life" );
+
+    # $foo isn't empty
+    isnt( $foo, '',     "Got some foo" );
+
+=begin original
+
+are similar to these:
+
+=end original
+
+次と似ています:
+
+    ok( ultimate_answer() eq 42,        "Meaning of Life" );
+    ok( $foo ne '',     "Got some foo" );
+
+(覚えかた:  "This is that."  "This isn't that.")
+
+=begin original
+
+C<undef> will only ever match C<undef>.  So you can test a value
+against C<undef> like this:
+
+=end original
+
+C<undef>は C<undef>にのみマッチします。C<undef>にたいして値をテストしたければ、
+次のようにします:
+
+    is($not_defined, undef, "undefined as expected");
+
+=begin original
+
+(Mnemonic:  "This is that."  "This isn't that.")
+
+=end original
+
+(覚え方:  "This is that."  "This isn't that.")
+
+=begin original
+
+So why use these?  They produce better diagnostics on failure.  ok()
+cannot know what you are testing for (beyond the name), but is() and
+isnt() know what the test was and why it failed.  For example this
+test:
+
+=end original
+
+どうしてこれらを使うのでしょう？ is() と isnt() は、失敗に関して、よりよい診断をだします。
+ok()は、(名前以上には)何のためにテストをしているのか知ることが出来ませんが、
+is()とisnt()は、テストが何で、テストがなぜ失敗したかを知っています。
+たとえばこのテスト：
+
+    my $foo = 'waffle';  my $bar = 'yarblokos';
+    is( $foo, $bar,   'Is foo the same as bar?' );
+
+=begin original
+
+Will produce something like this:
+
+=end original
+
+このようなものを出力します:
+
+    not ok 17 - Is foo the same as bar?
+    #   Failed test 'Is foo the same as bar?'
+    #   in foo.t at line 139.
+    #          got: 'waffle'
+    #     expected: 'yarblokos'
+
+=begin original
+
+So you can figure out what went wrong without rerunning the test.
+
+=end original
+
+これで、テストを再度走らせずに何が間違ったのか、判断できます。
+
+=begin original
+
+You are encouraged to use is() and isnt() over ok() where possible,
+however do not be tempted to use them to find out if something is
+true or false!
+
+=end original
+
+可能なら、is() と isnt()をok()の代わりに使うことを勧めます。
+ですが、何かが、真であるか偽であるかを見つけ出すために、
+is() と isnt() を使おうとしてはいけません!
+
+  # XXX BAD!
+  is( exists $brooklyn{tree}, 1, 'A tree grows in Brooklyn' );
+
+=begin original
+
+This does not check if C<exists $brooklyn{tree}> is true, it checks if
+it returns 1.  Very different.  Similar caveats exist for false and 0.
+In these cases, use ok().
+
+=end original
+
+このコードは、C<exsits $brooklyn{tree}> が真であるかどうかをチェックしません。
+このコードは、1を返すかどうかをチェックします。これらはまったく違います。
+似たような警告は、偽 と 0 にも在ります。こういうケースでは、ok() を使います。
+
+  ok( exists $brooklyn{tree},    'A tree grows in Brooklyn' );
+
+=begin original
+
+A simple call to isnt() usually does not provide a strong test but there
+are cases when you cannot say much more about a value than that it is
+different from some other value:
+
+=end original
+
+単純に isnt() を呼び出すのは、普通、強いテストを提供しません。
+値について他の値から違っていることより値について言えないような時に、
+適しています。
+
+
+  new_ok $obj, "Foo";
+
+  my $clone = $obj->clone;
+  isa_ok $obj, "Foo", "Foo->clone";
+
+  isnt $obj, $clone, "clone() produces a different object";
+
+=begin original
+
+For those grammatical pedants out there, there's an C<isn't()>
+function which is an alias of isnt().
+
+=end original
+
+文法学者ぶる人のために、書いておくと、C<isn't()> 関数は isnt()関数の
+エイリアスとして存在してます。
+
+=item B<like>
+
+  like( $got, qr/expected/, $test_name );
+
+=begin original
+
+Similar to ok(), like() matches $got against the regex C<qr/expected/>.
+
+=end original
+
+ok() と似ていますが、like() は、 引数の$gotを正規表現のC<qr/expected/>にマッチさせます。
+
+=begin original
+
+So this:
+
+=end original
+
+このように:
+
+    like($got, qr/expected/, 'this is like that');
+
+=begin original
+
+is similar to:
+
+=end original
+
+これは、次と似ています:
+
+    ok( $got =~ m/expected/, 'this is like that');
+
+=begin original
+
+(Mnemonic "This is like that".)
+
+=end original
+
+(覚えかた  "This is like that".)
+
+=begin original
+
+The second argument is a regular expression.  It may be given as a
+regex reference (i.e. C<qr//>) or (for better compatibility with older
+perls) as a string that looks like a regex (alternative delimiters are
+currently not supported):
+
+=end original
+
+二番目の引数は正規表現です。正規表現のリファレンス
+(たとえば、C<qr//>)や、(古いPerlと、より互換性を持たせるなら)
+正規表現に見える文字列(代替の区切りは、現在サポートされていません)として与えられます。
+
+    like( $got, '/expected/', 'this is like that' );
+
+=begin original
+
+Regex options may be placed on the end (C<'/expected/i'>).
+
+=end original
+
+正規表現のオプションは終わりに置かれます (C<'/expected/i'>)。
+
+=begin original
+
+Its advantages over ok() are similar to that of is() and isnt().  Better
+diagnostics on failure.
+
+=end original
+
+ok()と比べたときの利点は、is() と isnt()の利点に似ています。
+失敗に関して、よく診断します。
+
+=item B<unlike>
+
+  unlike( $got, qr/expected/, $test_name );
+
+=begin original
+
+Works exactly as like(), only it checks if $got B<does not> match the
+given pattern.
+
+=end original
+
+like()のように働きますが、 $got が与えたパターンにマッチB<しない>ことだけを
+チェックします。
+
+=item B<cmp_ok>
+
+  cmp_ok( $got, $op, $expected, $test_name );
+
+=begin original
+
+Halfway between C<ok()> and C<is()> lies C<cmp_ok()>.  This allows you
+to compare two arguments using any binary perl operator.  The test
+passes if the comparison is true and fails otherwise.
+
+=end original
+
+C<ok()> と C<is()> の中間に C<cmp_ok()> があります。 
+これは、すべてのバイナリのPerlの演算子を使って、二つの引数を比較することを許します。
+The test passes if the comparison is true and fails otherwise.
+
+    # ok( $got eq $expected );
+    cmp_ok( $got, 'eq', $expected, 'this eq that' );
+
+    # ok( $got == $expected );
+    cmp_ok( $got, '==', $expected, 'this == that' );
+
+    # ok( $got && $expected );
+    cmp_ok( $got, '&&', $expected, 'this && that' );
+    ...etc...
+
+=begin original
+
+Its advantage over ok() is when the test fails you'll know what $got
+and $expected were:
+
+=end original
+
+ok()と比べたときの cmp_ok の 利点は、テストが失敗したときに、
+$got と $expected が何かがわかることです。
+
+    not ok 1
+    #   Failed test in foo.t at line 12.
+    #     '23'
+    #         &&
+    #     undef
+
+=begin original
+
+It's also useful in those cases where you are comparing numbers and
+is()'s use of C<eq> will interfere:
+
+=end original
+
+cmp_ok は、数を比較する際や、is() を eq として使うことが、干渉する際に、有益でしょう:
+
+    cmp_ok( $big_hairy_number, '==', $another_big_hairy_number );
+
+=begin original
+
+It's especially useful when comparing greater-than or smaller-than 
+relation between values:
+
+=end original
+
+2つの値の大小の比較に使うと、非常に便利です。
+
+    cmp_ok( $some_value, '<=', $upper_limit );
+
+=cut
+
+=item B<can_ok>
+
+  can_ok($module, @methods);
+  can_ok($object, @methods);
+
+=begin original
+
+Checks to make sure the $module or $object can do these @methods
+(works with functions, too).
+
+=end original
+
+$module か $object が 複数のメソッド(または、関数)@methodsを実行できるかをチェックします。
+
+    can_ok('Foo', qw(this that whatever));
+
+=begin original
+
+is almost exactly like saying:
+
+=end original
+
+上の表現は、実際は、以下のような意味です:
+
+    ok( Foo->can('this') && 
+        Foo->can('that') && 
+        Foo->can('whatever') 
+      );
+
+=begin original
+
+only without all the typing and with a better interface.  Handy for
+quickly testing an interface.
+
+=end original
+
+すべてをタイプしなくていい、よりよいインターフェースです。
+素早いテストのための、手ごろなインターフェースです。
+
+=begin original
+
+No matter how many @methods you check, a single can_ok() call counts
+as one test.  If you desire otherwise, use:
+
+=end original
+
+いくつの @methods があるか、チェックすることは、大したことではありません。
+一つの can_ok() は一つのテストとして、カウントされます。
+別の方法で、やりたいなら、次のように使います:
+
+
+    foreach my $meth (@methods) {
+        can_ok('Foo', $meth);
+    }
+
+=item B<isa_ok>
+
+  isa_ok($object,   $class, $object_name);
+  isa_ok($subclass, $class, $object_name);
+  isa_ok($ref,      $type,  $ref_name);
+
+=begin original
+
+Checks to see if the given C<< $object->isa($class) >>.  Also checks to make
+sure the object was defined in the first place.  Handy for this sort
+of thing:
+
+=end original
+
+C<< $object->isa($class) >>が与えられているかどうかを見るためのチェック。
+オブジェクトが最初の場所で定義されているか確かめるためのチェックでもあります。
+
+    my $obj = Some::Module->new;
+    isa_ok( $obj, 'Some::Module' );
+
+=begin original
+
+where you'd otherwise have to write
+
+=end original
+
+代わりに次のように書けます：
+
+    my $obj = Some::Module->new;
+    ok( defined $obj && $obj->isa('Some::Module') );
+
+=begin original
+
+to safeguard against your test script blowing up.
+
+=end original
+
+テストscriptが、吹っ飛ぶのを防ぐためのセーフガードです。
+
+=begin original
+
+You can also test a class, to make sure that it has the right ancestor:
+
+=end original
+
+クラスもテストできます。正しい先祖か確かめます。
+
+    isa_ok( 'Vole', 'Rodent' );
+
+=begin original
+
+It works on references, too:
+
+=end original
+
+リファレンスでも動きます：
+
+    isa_ok( $array_ref, 'ARRAY' );
+
+=begin original
+
+The diagnostics of this test normally just refer to 'the object'.  If
+you'd like them to be more specific, you can supply an $object_name
+(for example 'Test customer').
+
+=end original
+
+このテストの診断は、通常、ただ、'そのオブジェクト'のリファレンスです。
+それらをもっと特定したいなら、$object_name
+(たとえば、'Test customer')を供給できます。
+
+=item B<new_ok>
+
+  my $obj = new_ok( $class );
+  my $obj = new_ok( $class => \@args );
+  my $obj = new_ok( $class => \@args, $object_name );
+
+=begin original
+
+A convenience function which combines creating an object and calling
+isa_ok() on that object.
+
+=end original
+
+オブジェクトを作り、 そのオブジェクトで、isa_ok() の呼び出しをくっつけた
+便利な関数です。
+
+=begin original
+
+It is basically equivalent to:
+
+=end original
+
+これは、次のものと基本的に同じです:
+
+    my $obj = $class->new(@args);
+    isa_ok $obj, $class, $object_name;
+
+=begin original
+
+If @args is not given, an empty list will be used.
+
+=end original
+
+ ＠ argsが与えられなければ、空のリストが使われます。
+
+=begin original
+
+This function only works on new() and it assumes new() will return
+just a single object which isa C<$class>.
+
+=end original
+
+この関数は、 new() でのみ動き、new()が　C<$class>と isa である
+一つのオブジェクトを返すことを想定しています。
+
+
+=cut
+
+=item B<subtest>
+
+    subtest $name => \&code;
+
+=begin original
+
+subtest() runs the &code as its own little test with its own plan and
+its own result.  The main test counts this as a single test using the
+result of the whole subtest to determine if its ok or not ok.
+
+=end original
+
+subtest() &code をそれ自身の計画と結果をもつそれ自身小さなテストとして、実行します。
+メインのテストは一つのテストとしてカウントします。
+サブテスト全体の結果を使って、ok か not ok か決定します。
+
+=begin original
+
+For example...
+
+=end original
+
+例えば...
+
+  use Test::More tests => 3;
+ 
+  pass("First test");
+
+  subtest 'An example subtest' => sub {
+      plan tests => 2;
+
+      pass("This is a subtest");
+      pass("So is this");
+  };
+
+  pass("Third test");
+
+=begin original
+
+This would produce.
+
+=end original
+
+以下のように出力されます。
+
+  1..3
+  ok 1 - First test
+      # Subtest: An example subtest
+      1..2
+      ok 1 - This is a subtest
+      ok 2 - So is this
+  ok 2 - An example subtest
+  ok 3 - Third test
+
+=begin original
+
+A subtest may call "skip_all".  No tests will be run, but the subtest is
+considered a skip.
+
+=end original
+
+subtestは、"skip_all"を呼んでもかまいません。テストは実行されませんが、
+subtest は skip されたと考えられます。
+
+  subtest 'skippy' => sub {
+      plan skip_all => 'cuz I said so';
+      pass('this test will never be run');
+  };
+
+=begin original
+
+Returns true if the subtest passed, false otherwise.
+
+=end original
+
+subtestが通れば、真を返し、他は偽を返します。
+
+=begin original
+
+Due to how subtests work, you may omit a plan if you desire.  This adds an
+implicit C<done_testing()> to the end of your subtest.  The following two
+subtests are equivalent:
+
+=end original
+
+サブテストがどのように動かすかによって、望むなら計画を省くことができます。
+C<done_testing()> を暗に行い、サブテストを終わらせます。以下の2つの
+サブテストは同じです:
+
+  subtest 'subtest with implicit done_testing()', sub {
+      ok 1, 'subtests with an implicit done testing should work';
+      ok 1, '... and support more than one test';
+      ok 1, '... no matter how many tests are run';
+  };
+
+  subtest 'subtest with explicit done_testing()', sub {
+      ok 1, 'subtests with an explicit done testing should work';
+      ok 1, '... and support more than one test';
+      ok 1, '... no matter how many tests are run';
+      done_testing();
+  };
+
+
+=cut
+
+=item B<pass>
+
+=item B<fail>
+
+  pass($test_name);
+  fail($test_name);
+
+=begin original
+
+Sometimes you just want to say that the tests have passed.  Usually
+the case is you've got some complicated condition that is difficult to
+wedge into an ok().  In this case, you can simply use pass() (to
+declare the test ok) or fail (for not ok).  They are synonyms for
+ok(1) and ok(0).
+
+=end original
+
+時には、ただ、テストがパスしたと示したいでしょう。
+普通、このケースは、ok()に、押し込むことが難しい複雑な条件になっています。
+こういう場合、単純にpass()(テストがokであると宣言するために)か、fail(not ok のために)
+かを使えます。これらは、ok(1)と、ok(0)の同意語です。
+
+=begin original
+
+Use these very, very, very sparingly.
+
+=end original
+
+pass() と fail() を使うことはひじょーに慎重に判断してください。
+
+=cut
+
+=back
+
+=head2 Module tests
+
+(モジュールのテスト)
+
+=begin original
+
+Sometimes you want to test if a module, or a list of modules, can
+successfully load.  For example, you'll often want a first test which
+simply loads all the modules in the distribution to make sure they
+work before going on to do more complicated testing.
+
+=end original
+
+モジュール、またはモジュールのリストが正しくロードされるかをテストをしたい場合、
+例えば、より複雑なテストを行う前に、ディストリビューションの全てのモジュールが
+動くことを確かめるために、単純にロードする、最初のテストが欲しい場合がよくあるでしょう。
+
+=begin original
+
+For such purposes we have C<use_ok> and C<require_ok>.
+
+=end original
+
+そのような目的のために、C<use_ok>と、C<require_ok>があります。
+
+=over 4
+
+=item B<require_ok>
+
+   require_ok($module);
+   require_ok($file);
+
+=begin original
+
+Tries to C<require> the given $module or $file.  If it loads
+successfully, the test will pass.  Otherwise it fails and displays the
+load error.
+
+=end original
+
+与えられた $module か $file を C<require> を試して、成功すれば、
+テストはパスします。そうでなければ、失敗し、ロードエラーを表示します。
+
+=begin original
+
+C<require_ok> will guess whether the input is a module name or a
+filename.
+
+=end original
+
+C<require_ok>は、入力がモジュール名かファイル名かのどちらかをル推測します。
+
+=begin original
+
+No exception will be thrown if the load fails.
+
+=end original
+
+ロードが失敗しても、例外を出しません。
+
+    # require Some::Module
+    require_ok "Some::Module";
+
+    # require "Some/File.pl";
+    require_ok "Some/File.pl";
+
+    # stop testing if any of your modules will not load
+    for my $module (@module) {
+        require_ok $module or BAIL_OUT "Can't load $module";
+    }
+
+
+=cut
+
+=item B<use_ok>
+
+   BEGIN { use_ok($module); }
+   BEGIN { use_ok($module, @imports); }
+
+=begin original
+
+Like C<require_ok>, but it will C<use> the $module in question and
+only loads modules, not files.
+
+=end original
+
+C<require_ok>と似ていますが、$module を C<use>します。
+モジュールのみをロードし、ファイルは行いません。
+
+=begin original
+
+If you just want to test a module can be loaded, use C<require_ok>.
+
+=end original
+
+モジュールがロードされるかをテストしたいだけなら、C<require_ok>を使ってください。
+
+=begin original
+
+If you just want to load a module in a test, we recommend simply using
+C<use> directly.  It will cause the test to stop.
+
+=end original
+
+テストでモジュールをロードしたければ、単純に C<use>を直接に使うことを
+推奨します。テストを停止する原因になります。
+
+=begin original
+
+It's recommended that you run use_ok() inside a BEGIN block so its
+functions are exported at compile-time and prototypes are properly
+honored.
+
+=end original
+
+BEGIN ブロック内で、use_ok() を走らせることを推奨します。
+これにより、この関数は、コンパイル時にexportされ、プロトタイプを適切に受け取ります。
+
+=begin original
+
+If @imports are given, they are passed through to the use.  So this:
+
+=end original
+
+ ＠ import が与えれた場合、use の際に渡されます。次のように :
+
+   BEGIN { use_ok('Some::Module', qw(foo bar)) }
+
+=begin original
+
+is like doing this:
+
+=end original
+
+次のようにするのと同じです：
+
+   use Some::Module qw(foo bar);
+
+=begin original
+
+Version numbers can be checked like so:
+
+=end original
+
+バージョンは次のようにチェックできます:
+
+   # Just like "use Some::Module 1.02"
+   BEGIN { use_ok('Some::Module', 1.02) }
+
+=begin original
+
+Don't try to do this:
+
+=end original
+
+次のようにしようとしてはいけません：
+
+   BEGIN {
+       use_ok('Some::Module');
+
+       ...some code that depends on the use...
+       ...happening at compile time...
+   }
+
+=begin original
+
+because the notion of "compile-time" is relative.  Instead, you want:
+
+=end original
+
+"compile-time"の記述が関係するからです。代わりに、次のようにしましょう。
+
+  BEGIN { use_ok('Some::Module') }
+  BEGIN { ...some code that depends on the use... }
+
+=cut
+
+If you want the equivalent of C<use Foo ()>, use a module but not
+import anything, use C<require_ok>.
+
+=end original
+
+C<use Foo ()>と同等のものがほしければ、,モジュールを使うけれど、
+何もインポートしない、C<require_ok>を使ってください。
+
+  BEGIN { require_ok "Foo" }
+
+=cut
+
+=back
+
+
+=head2 Complex data structures
+
+(複雑なデータ構造)
+
+=begin original
+
+Not everything is a simple eq check or regex.  There are times you
+need to see if two data structures are equivalent.  For these
+instances Test::More provides a handful of useful functions.
+
+=end original
+
+全てが、単純なeq チェックや、正規表現 ではありません。
+たとえば、二つの配列がイコールであるかどうかを見る必要があるときもあります。
+こういった例のために、Test::Moreは、ちょっとした有益な関数を提供しています。
+
+=begin original
+
+B<NOTE> I'm not quite sure what will happen with filehandles.
+
+=end original
+
+B<注意>ファイルハンドルについて起きることについて、あまり確信がありません。
+
+=over 4
+
+=item B<is_deeply>
+
+  is_deeply( $got, $expected, $test_name );
+
+=begin original
+
+Similar to is(), except that if $got and $expected are references, it
+does a deep comparison walking each data structure to see if they are
+equivalent.  If the two structures are different, it will display the
+place where they start differing.
+
+=end original
+
+is()と似ていますが、$got と $expectedが、リファレンスです。
+それぞれのデータの構造を見てまわり、それぞれが、イコールかどうか、深い比較をします。
+二つの構造が違っていれば、二つが違い始めた場所を示します。
+
+=begin original
+
+is_deeply() compares the dereferenced values of references, the
+references themselves (except for their type) are ignored.  This means
+aspects such as blessing and ties are not considered "different".
+
+=end original
+
+is_deeply() は、リファレンスの値の違いを比較します、
+リファレンスそれ自身(その型をのぞき)は無視されます。
+つまり、blessや tie のような側面は、"違う"と考えられません。
+
+=begin original
+
+is_deeply() currently has very limited handling of function reference
+and globs.  It merely checks if they have the same referent.  This may
+improve in the future.
+
+=end original
+
+is_deeply() は、今のところ、関数リファレンスとglobのハンドリングは
+非常に限定的です。単純に、同じ referent を持っているかをチェックします。
+将来改善されるかもしれません。
+
+=begin original
+
+L<Test::Differences> and L<Test::Deep> provide more in-depth functionality
+along these lines.
+
+=end original
+
+L<Test::Differences>とL<Test::Deep>は、より、徹底的な機能性を提供しています。
+
+=cut
+
+=back
+
+
+=head2 Diagnostics
+
+(複数の診断)
+
+=begin original
+
+If you pick the right test function, you'll usually get a good idea of
+what went wrong when it failed.  But sometimes it doesn't work out
+that way.  So here we have ways for you to write your own diagnostic
+messages which are safer than just C<print STDERR>.
+
+=end original
+
+正しいテスト関数を選んだなら、ふつう、そのテスト関数が失敗した場合に、
+何が間違っているかについてよい情報を得ることができるでしょう。ですが、時に、
+そういう風には、うまく働かないこともあります。
+そのために、自分で自分自身の診断メッセージを書く方法があります。
+C<print STDERR> よりも、安全です。
+
+=over 4
+
+=item B<diag>
+
+  diag(@diagnostic_message);
+
+=begin original
+
+Prints a diagnostic message which is guaranteed not to interfere with
+test output.  Like C<print> @diagnostic_message is simply concatenated
+together.
+
+=end original
+
+テストの出力に干渉しないと保証されている診断メッセージを出力します。
+C<print> のように、@diagnostic_message を単純に一緒につなぎます。
+
+=begin original
+
+Returns false, so as to preserve failure.
+
+=end original
+
+失敗のままにするために、偽を返します。
+
+=begin original
+
+Handy for this sort of thing:
+
+=end original
+
+次のような場合に、手ごろです：
+
+    ok( grep(/foo/, @users), "There's a foo user" ) or
+        diag("Since there's no foo, check that /etc/bar is set up right");
+
+=begin original
+
+which would produce:
+
+=end original
+
+次のようになります：
+
+    not ok 42 - There's a foo user
+    #   Failed test 'There's a foo user'
+    #   in foo.t at line 52.
+    # Since there's no foo, check that /etc/bar is set up right.
+
+=begin original
+
+You might remember C<ok() or diag()> with the mnemonic C<open() or
+die()>.
+
+=end original
+
+C<ok() or diag()>を、C<open() or die()> のように覚えると覚えやすいでしょう。
+
+=begin original
+
+B<NOTE> The exact formatting of the diagnostic output is still
+changing, but it is guaranteed that whatever you throw at it won't
+interfere with the test.
+
+=end original
+
+B<注意> 診断の出力のためのフォーマットは、まだまだ流動的です。
+changing, but it is guaranteed that whatever you throw at it won't
+しかし、それに何を渡してもテストに干渉しないことは保証されています。
+
+=item B<note>
+
+  note(@diagnostic_message);
+
+=begin original
+
+Like diag(), except the message will not be seen when the test is run
+in a harness.  It will only be visible in the verbose TAP stream.
+
+=end original
+
+diag()と似ていますが，harnessでテストが動いている場合には、表示されません。
+冗長なTAPストリームでのみ、見られます。
+
+
+=begin original
+
+Handy for putting in notes which might be useful for debugging, but
+don't indicate a problem.
+
+=end original
+
+デバッグに有用なメモをおくのに手ごろですが，問題を指摘するのに
+使ってはいけません。
+
+    note("Tempfile is $tempfile");
+
+=cut
+
+=item B<explain>
+
+  my @dump = explain @diagnostic_message;
+
+
+=begin original
+
+Will dump the contents of any references in a human readable format.
+Usually you want to pass this into C<note> or C<diag>.
+
+=end original
+
+人が読みやすいフォーマットで、リファレンスの内容をダンプします。
+C<not> や C<diag>に与えたいと思うでしょう。
+
+=begin original
+
+Handy for things like...
+
+=end original
+
+次のような場合に、手ごろです：
+
+    is_deeply($have, $want) || diag explain $have;
+
+
+=begin original
+
+or
+
+=end original
+
+または、
+
+    note explain \%args;
+    Some::Class->method(%args);
+
+
+=cut
+
+=back
+
+
+=head2 Conditional tests
+
+(条件テスト)
+
+=begin original
+
+Sometimes running a test under certain conditions will cause the
+test script to die.  A certain function or method isn't implemented
+(such as fork() on MacOS), some resource isn't available (like a 
+net connection) or a module isn't available.  In these cases it's
+necessary to skip tests, or declare that they are supposed to fail
+but will work in the future (a todo test).
+
+=end original
+
+ある条件下でテストを動かすことによって、テストスクリプトが死ぬ時があります。
+(MacOSでのfork()のような)特定の関数やメソッドは実装されていなかったり、
+(ネット接続のような)いくつかのリソースが利用できなかったり、
+モジュールが利用できなかったりとか。
+こういったケースでは、テストをスキップしなければならないか、
+そうでなければ、失敗することが予想されるけれど、
+将来的に動く(a todo test)であろうということを宣言しなければなりません。
+
+=begin original
+
+For more details on the mechanics of skip and todo tests see
+L<Test::Harness>.
+
+=end original
+
+skip と todo テストの機構の詳細は、C<Test::Harness>を見て下さい。
+
+=begin original
+
+The way Test::More handles this is with a named block.  Basically, a
+block of tests which can be skipped over or made todo.  It's best if I
+just show you...
+
+=end original
+
+名前のついたブロックと一緒にあるTest::More ハンドルの使い方。
+基本的にテストのブロックは、スキップさせるか、todo にするかです。
+ただコードを見せるのが最善でしょう…
+
+=over 4
+
+=item B<SKIP: BLOCK>
+
+  SKIP: {
+      skip $why, $how_many if $condition;
+
+      ...normal testing code goes here...
+  }
+
+=begin original
+
+This declares a block of tests that might be skipped, $how_many tests
+there are, $why and under what $condition to skip them.  An example is
+the easiest way to illustrate:
+
+=end original
+
+これは、スキップするテストのブロックを宣言します。
+$how_many はテストの数、 $why は理由、$conditionは、
+どういう条件で、これらのテストをスキップするのかを意味します。
+最も簡単な例を見せます：
+
+
+    SKIP: {
+        eval { require HTML::Lint };
+
+        skip "HTML::Lint not installed", 2 if $@;
+
+        my $lint = new HTML::Lint;
+        isa_ok( $lint, "HTML::Lint" );
+
+        $lint->parse( $html );
+        is( $lint->errors, 0, "No errors found in HTML" );
+    }
+
+=begin original
+
+If the user does not have HTML::Lint installed, the whole block of
+code I<won't be run at all>.  Test::More will output special ok's
+which Test::Harness interprets as skipped, but passing, tests.
+
+=end original
+
+ユーザが、HTML::Lint をインストールしていなければ、全てのブロックコードは、
+I<まったく実行されないでしょう>。 Test::Moreは、特別な ok() を出力し、
+Test::Harnes は、テストをスキップしたが、合格したと解釈します。
+
+=begin original
+
+It's important that $how_many accurately reflects the number of tests
+in the SKIP block so the # of tests run will match up with your plan.
+If your plan is C<no_plan> $how_many is optional and will default to 1.
+
+=end original
+
+テストの数が、計画にマッチするために、
+$how_many が正しくSKIP ブロックの中のテストの数を反映することは重要です。
+もし、計画がC<no_plan>であれば、$how_many はオプションで、デフォルトは1になります。
+
+=begin original
+
+It's perfectly safe to nest SKIP blocks.  Each SKIP block must have
+the label C<SKIP>, or Test::More can't work its magic.
+
+=end original
+
+ネストするSKIPブロックは完全に安全です。それぞれのSKIPブロックには、
+C<SKIP>ラベルがなければなりません、そうしないと、Test::Moreは、その魔法をうまく使えません。
+
+=begin original
+
+You don't skip tests which are failing because there's a bug in your
+program, or for which you don't yet have code written.  For that you
+use TODO.  Read on.
+
+=end original
+
+失敗するテストをスキップしてはいけません。失敗するのは、プログラムにバグがあるからですし、
+そうでなければ、まだコードを書いていないからです。
+TODO の使い方を書くので、読み続けてください。
+
+=item B<TODO: BLOCK>
+
+    TODO: {
+        local $TODO = $why if $condition;
+
+        ...ふつうのテストコードをここに続けてください...
+    }
+
+=begin original
+
+Declares a block of tests you expect to fail and $why.  Perhaps it's
+because you haven't fixed a bug or haven't finished a new feature:
+
+=end original
+
+失敗すると予測しているテストと、$why のブロックを宣言します。
+たぶん、バグをまだ直していないか、新しい機能を作り終えていないのでしょう。
+
+    TODO: {
+        local $TODO = "URI::Geller not finished";
+
+        my $card = "Eight of clubs";
+        is( URI::Geller->your_card, $card, 'Is THIS your card?' );
+
+        my $spoon;
+        URI::Geller->bend_spoon;
+        is( $spoon, 'bent',    "Spoon bending, that's original" );
+    }
+
+=begin original
+
+With a todo block, the tests inside are expected to fail.  Test::More
+will run the tests normally, but print out special flags indicating
+they are "todo".  Test::Harness will interpret failures as being ok.
+Should anything succeed, it will report it as an unexpected success.
+You then know the thing you had todo is done and can remove the
+TODO flag.
+
+=end original
+
+todoブロックでは、その中のテストは、失敗すると予期されます。Test::More は、
+普通にテストを行いますが、特別なフラグを出力し、それのテストが「todo」であることを示します。
+Test::Harness は、この失敗を ok であると解釈します。
+なんでも成功にし、予期しない成功と、報告します。
+todoが解消されたと分かったら、TODOフラグを外すことが出来ます。
+
+=begin original
+
+The nice part about todo tests, as opposed to simply commenting out a
+block of tests, is it's like having a programmatic todo list.  You know
+how much work is left to be done, you're aware of what bugs there are,
+and you'll know immediately when they're fixed.
+
+=end original
+
+todo テストの良いところは、テストのブロックを単純にコメントアウトすることではなく、
+プログラマ的なtodoリストであるようになることです。
+どれくらいするべき仕事が残っているのか分かるし、どのようなバグがあるのかも気付きます。
+また、それらのテストが修正された場合、即座に識別することが出来るでしょう。
+
+=begin original
+
+Once a todo test starts succeeding, simply move it outside the block.
+When the block is empty, delete it.
+
+=end original
+
+一度、todoテストが成功し始めると、単純に、ブロックの外側にtodoテストを移します。
+ブロックが空なら、削除します。
+
+=item B<todo_skip>
+
+    TODO: {
+        todo_skip $why, $how_many if $condition;
+
+        ...normal testing code...
+    }
+
+=begin original
+
+With todo tests, it's best to have the tests actually run.  That way
+you'll know when they start passing.  Sometimes this isn't possible.
+Often a failing test will cause the whole program to die or hang, even
+inside an C<eval BLOCK> with and using C<alarm>.  In these extreme
+cases you have no choice but to skip over the broken tests entirely.
+
+=end original
+
+todo テストでは、実際にテストをなるべく走らせようとします。
+このように、それらのテストがいつ通過し始めるかを知るでしょう。
+こういうことが、可能でない時があります。
+失敗するテストは全てのプログラムが死ぬか、ハングする原因になることがよくあります。
+C<eval BLOCK>の内側で、C<alarm>を使っても。
+このような極端なケースでは、壊れたテストを完全にスキップする以外には、選択の余地はありません。
+
+=begin original
+
+The syntax and behavior is similar to a C<SKIP: BLOCK> except the
+tests will be marked as failing but todo.  Test::Harness will
+interpret them as passing.
+
+=end original
+
+todoではなくテストが失敗としてマークされる以外は、
+構文や振る舞いがC<SKIP: BLOCK>に似ています。
+Test::Harness は、テストに合格していると解釈します。
+
+=item When do I use SKIP vs. TODO?
+
+(SKIP 対 TODO をどのように使い分けるのでしょう？)
+
+=begin original
+
+B<If it's something the user might not be able to do>, use SKIP.
+This includes optional modules that aren't installed, running under
+an OS that doesn't have some feature (like fork() or symlinks), or maybe
+you need an Internet connection and one isn't available.
+
+=end original
+
+B<もし、ユーザが出来そうにないときには>、SKIPを使ってください。
+これには、インストールされていないオプショナルなモジュールや、
+(fork()やsymlinksなどの)機能を持っていないOSで実行することや、
+インターネット接続を必要としているのに、それをユーザが利用できないことも含みます。
+
+=begin original
+
+B<If it's something the programmer hasn't done yet>, use TODO.  This
+is for any code you haven't written yet, or bugs you have yet to fix,
+but want to put tests in your testing script (always a good idea).
+
+=end original
+
+B<もし、プログラマがまだ、やっていないときには>、TODO を使ってください。
+これは、テストscriptに、テストを置きたい(常によい考えです)けれども、
+まだ書いていないコードや、まだ直していないバグなどです。
+
+=back
+
+
+=head2 Test control
+
+(テストの制御)
+
+=over 4
+
+=item B<BAIL_OUT>
+
+    BAIL_OUT($reason);
+
+=begin original
+
+Indicates to the harness that things are going so badly all testing
+should terminate.  This includes the running of any additional test scripts.
+
+=end original
+
+悲惨ななことになったため、すべてのテストを終了させるように、harnessに伝えます。
+これは、どんな追加のテストスクリプトの実行も含みます。
+
+=begin original
+
+This is typically used when testing cannot continue such as a critical
+module failing to compile or a necessary external utility not being
+available such as a database connection failing.
+
+=end original
+
+データベース接続のような、重要なモジュールのコンパイルエラーや
+必須の外部ユーティリティが利用できないようなために、
+テストが続けられない場合に、典型的に使われます。
+
+=begin original
+
+The test will exit with 255.
+
+=end original
+
+テストは255で終了します。
+
+For even better control look at L<Test::Most>.
+
+L<Test::Most>に、よりよい制御があります。
+
+
+=cut
+
+=back
+
+
+=head2 Discouraged comparison functions
+
+(推奨されない比較関数)
+
+=begin original
+
+The use of the following functions is discouraged as they are not
+actually testing functions and produce no diagnostics to help figure
+out what went wrong.  They were written before is_deeply() existed
+because I couldn't figure out how to display a useful diff of two
+arbitrary data structures.
+
+=end original
+
+下記の関数の使用は推奨されません。これらは、実際にはテスト関数ではなく、
+何が間違っているかを突き止める助けとなる診断は提供しません。
+is_deeply() ができるより前に書かれた関数で、2つの任意のデータ構造の
+違いを表示する有効な方法を考え付くことが出来なかったためです。
+
+=begin original
+
+These functions are usually used inside an ok().
+
+=end original
+
+これらは、ok() の中で使われるのが普通です。
+
+    ok( eq_array(\@got, \@expected) );
+
+C<is_deeply()> can do that better and with diagnostics.  
+
+C<is_deeply()>は、より良いですし、診断もあります。
+
+    is_deeply( \@got, \@expected );
+
+=begin original
+
+They may be deprecated in future versions.
+
+=end original
+
+将来のバージョンでなくなるかもしれません。
+
+=over 4
+
+=item B<eq_array>
+
+  my $is_eq = eq_array(\@got, \@expected);
+
+=begin original
+
+Checks if two arrays are equivalent.  This is a deep check, so
+multi-level structures are handled correctly.
+
+=end original
+
+二つの配列がイコールかどうかをチェックします。これは、深いチェックであり、
+マルチレベルの構造が正確に扱われます。
+
+=item B<eq_hash>
+
+  my $is_eq = eq_hash(\%got, \%expected);
+
+=begin original
+
+Determines if the two hashes contain the same keys and values.  This
+is a deep check.
+
+=end original
+
+二つのハッシュが同じキーと値を含んでいるかどうかを調べます。
+これは深いチェックです。
+
+=item B<eq_set>
+
+  my $is_eq = eq_set(\@got, \@expected);
+
+=begin original
+
+Similar to eq_array(), except the order of the elements is B<not>
+important.  This is a deep check, but the irrelevancy of order only
+applies to the top level.
+
+=end original
+
+eq_array() とにていますが、要素の順番は重要ではありません。
+これは、深いチェックですが、順番の不整合は、トップレベルにしか適用されません。
+
+    ok( eq_set(\@got, \@expected) );
+
+=begin original
+
+Is better written:
+
+=end original
+
+より良い書き方:
+
+    is_deeply( [sort @got], [sort @expected] );
+
+=begin original
+
+B<NOTE> By historical accident, this is not a true set comparison.
+While the order of elements does not matter, duplicate elements do.
+
+=end original
+
+B<注意>。歴史的な都合により、これは、本当の set の比較ではありません。
+要素の順番が問題ではない上に、重複した要素も問題にしません。
+
+=begin original
+
+B<NOTE> eq_set() does not know how to deal with references at the top
+level.  The following is an example of a comparison which might not work:
+
+=end original
+
+B<注意>。eq_set() は、トップレベルでリファレンスをどう扱うかを知りません。
+以下のものは、動かない比較の例です。
+
+    eq_set([\1, \2], [\2, \1]);
+
+=begin original
+
+L<Test::Deep> contains much better set comparison functions.
+
+=end original
+
+L<Test::Deep> には、よりよい比較関数のセットがあります。
+
+=cut
+
+=back
+
+
+=head2 Extending and Embedding Test::More
+
+(Test::Moreの拡張と包含)
+
+=begin original
+
+Sometimes the Test::More interface isn't quite enough.  Fortunately,
+Test::More is built on top of Test::Builder which provides a single,
+unified backend for any test library to use.  This means two test
+libraries which both use Test::Builder B<can be used together in the
+same program>.
+
+=end original
+
+Test::More のインターフェースが、まったく十分でない時もあります。
+幸運なことに、Test::More は、Test::Builderの上に作られています。
+Test::Builder は、あらゆるテストライブラリーのための、一つの、統合された、バックエンドを提供しています。
+このことは、両方とも、Test::Builderを使っている、二つのテストライブラリーならば、
+B<同じプログラムでいっしょに使えること>を意味します
+
+=begin original
+
+If you simply want to do a little tweaking of how the tests behave,
+you can access the underlying Test::Builder object like so:
+
+=end original
+
+もし単純に、テストの挙動の仕方を微調整したければ、次のように、
+ベースとされたTest::Builderオブジェクトにアクセスできます:
+
+=over 4
+
+=item B<builder>
+
+    my $test_builder = Test::More->builder;
+
+=begin original
+
+Returns the Test::Builder object underlying Test::More for you to play
+with.
+
+=end original
+
+Test::Moreで遊ぶための、Test::Moreの基礎をなすTest::Builder オブジェクトを
+返します。
+
+=cut
+
+=back
+
+=head1 EXIT CODES
+
+(終了コード)
+
+=begin original
+
+If all your tests passed, Test::Builder will exit with zero (which is
+normal).  If anything failed it will exit with how many failed.  If
+you run less (or more) tests than you planned, the missing (or extras)
+will be considered failures.  If no tests were ever run Test::Builder
+will throw a warning and exit with 255.  If the test died, even after
+having successfully completed all its tests, it will still be
+considered a failure and will exit with 255.
+
+=end original
+
+すべてのテストがパスしたら、Test::Builderは 0 で終了します(通常です)。
+何か間違っていたら，間違った数で終了します。計画しているよりも、
+少ない(か、多い)か、見失ったか、余計なテストを走らせると、失敗したとみなされます。
+テストが実行されなければ、警告を投げ、255で終了します。
+テストが死んだら、たとえすべてのテストが成功しても、
+失敗とみなし、255で終了します。
+
+=begin original
+
+So the exit codes are...
+
+=end original
+
+終了コードは...
+
+    0                   すべてのテストが成功
+    255                 テストは死んだか、すべて成功したが、間違っている # of tests run
+    any other number    間違った数(失敗か、余計なものを含む)
+
+=begin original
+
+If you fail more than 254 tests, it will be reported as 254.
+
+=end original
+
+254以上のテストに失敗したら、254を報告します。
+
+=begin original
+
+B<NOTE>  This behavior may go away in future versions.
+
+=end original
+
+B<注意>。この振る舞いは、将来のバージョンでなくなるかもしれません。
+
+=head1 警告と注意
+
+=over 4
+
+=item 後方互換性
+
+=begin original
+
+Test::More works with Perls as old as 5.6.0.
+
+=end original
+
+Test::More はPerl 5.6.0で動きます。
+
+=head1 COMPATIBILITY
+
+(互換性)
+
+=begin original
+
+Test::More works with Perls as old as 5.8.1.
+
+=end original
+
+Test::Moreは、5.8.1 の古い Perl でも動きます。
+
+=begin original
+
+Thread support is not very reliable before 5.10.1, but that's
+because threads are not very reliable before 5.10.1.
+
+=end original
+
+5.10.1 より前では、スレッドサポートはあまり信頼できません。しかし、それは、
+threads が5.10.1 より前にあまり信頼でなかったからです。
+
+=begin original
+
+Although Test::More has been a core module in versions of Perl since 5.6.2, Test::More has evolved since then, and not all of the features you're used to will be present in the shipped version of Test::More. If you are writing a module, don't forget to indicate in your package metadata the minimum version of Test::More that you require. For instance, if you want to use C<done_testing()> but want your test script to run on Perl 5.10.0, you will need to explicitly require Test::More > 0.88.
+
+=end original
+
+Test::More は、Perl 5.6.2 のバージョンからコアモジュールですが、Test::More は、それから進化しています。よく使っている全ての機能が、Test::More のシップされたバージョンに存在するわけではありません。モジュールを書いているなら、パッケージのメタデータで、必要とする Test::More の最小のバージョンを指定していするのを忘れないでください。例えば、C<done_testing()> を使っており、ですが、スクリプトは、Perl 5.10.0 で動かしたいなら、Test::More > 0.88 が必要だと明示しなければなりません。
+
+=begin original
+
+Key feature milestones include:
+
+=end original
+
+重要な機能のマイルストーンは:
+
+=over 4
+
+=item subtests
+
+=begin original
+
+Subtests were released in Test::More 0.94, which came with Perl 5.12.0. Subtests did not implicitly call C<done_testing()> until 0.96; the first Perl with that fix was Perl 5.14.0 with 0.98.
+
+=end original
+
+サブテストは Test::More 0.94 でリリースされました。 Perl 5.12.0 に付属ます。サブテストは、0.96まで、暗黙的に、C<done_testing()>を呼びません; 0.98でされたこの修正がついている最初の Perl は、5.14.0 です。
+
+=item C<done_testing()>
+
+=begin original
+
+This was released in Test::More 0.88 and first shipped with Perl in 5.10.1 as part of Test::More 0.92. 
+
+=end original
+
+Test::More 0.88 でリリースされました。Test::More 0.92 は Perl 5.10.1 の一部として付属します。
+
+=item C<cmp_ok()>
+
+=begin original
+
+Although C<cmp_ok()> was introduced in 0.40, 0.86 fixed an important bug to make it safe for overloaded objects; the fixed first shipped with Perl in 5.10.1 as part of Test::More 0.92.
+
+=end original
+
+C<cmp_ok()> は、 0.40 で導入されましたが、0.86 で、オーバーロードされたオブジェクトを安全にするための重要なバグが修正されました; Test::More 0.92 の一部として、Perl 5.10.1 で最初にリリースされました。
+
+=item C<new_ok()> C<note()> and C<explain()>
+
+=begin original
+
+These were was released in Test::More 0.82, and first shipped with Perl in 5.10.1 as part of Test::More 0.92. 
+
+=end original
+
+これらは、Test::More 0.82 でリリースされました。Test::More 0.92 の一部として、Perl 5.10.1 で最初にリリースされました。
+
+=back
+
+=begin original
+
+There is a full version history in the Changes file, and the Test::More versions included as core can be found using L<Module::CoreList>:
+
+=end original
+
+変更ファイルの完全なバージョンヒストリーです。また、L<Module::CoreList>を使えば、コアとして含まれた Test::More のバージョンがわかります。
+
+    $ corelist -a Test::More
+
+
+=head1 CAVEATS and NOTES
+
+=over 4
+
+=item utf8 / "Wide character in print"
+
+=begin original
+
+If you use utf8 or other non-ASCII characters with Test::More you
+might get a "Wide character in print" warning.  Using C<binmode
+STDOUT, ":utf8"> will not fix it.  Test::Builder (which powers
+Test::More) duplicates STDOUT and STDERR.  So any changes to them,
+including changing their output disciplines, will not be seem by
+Test::More.
+
+=end original
+
+utf8 か non-ASCIIな文字をTest::Moreと一緒に使う場合、
+"Wide character in print"の警告が出るかもしれません。
+C<binmode STDOUT, ":utf8">を使っても、直りません。Test::Builder (
+Test::Moreに力を与えている) STDOUTとSTDERRを複製しています。
+そのため、それらへのどんな変更も、それらの出力の仕方の変更も含み、
+Test::Moreにはわかりません。
+
+=begin original
+
+One work around is to apply encodings to STDOUT and STDERR as early
+as possible and before Test::More (or any other Test module) loads.
+
+=end original
+
+1つのワークアラウンドは Test::More(か、ほかのTestモジュール)がロードされる前に、
+STDOUTとSTDERRに可能な限り早くエンコーディングを適用することです。
+
+    use open ':std', ':encoding(utf8)';
+    use Test::More;
+
+=begin original
+
+A more direct work around is to change the filehandles used by
+Test::Builder.
+
+=end original
+
+より直接的な対処方法としては、Test::Builderを使ってファイルハンドルを変更することです。
+
+
+    my $builder = Test::More->builder;
+    binmode $builder->output,         ":encoding(utf8)";
+    binmode $builder->failure_output, ":encoding(utf8)";
+    binmode $builder->todo_output,    ":encoding(utf8)";
+
+
+=item Overloaded objects
+
+(オーバーロードされたオブジェクト)
+
+=begin original
+
+String overloaded objects are compared B<as strings> (or in cmp_ok()'s
+case, strings or numbers as appropriate to the comparison op).  This
+prevents Test::More from piercing an object's interface allowing
+better blackbox testing.  So if a function starts returning overloaded
+objects instead of bare strings your tests won't notice the
+difference.  This is good.
+
+=end original
+
+オーバーロードされたオブジェクトはB<文字列として>(または、 cmp_ok()では、
+比較するオペレーターにしたがって、文字列か数字として)比較されます。これは、
+Test::Moreが、より良いブラックボックステストを許しているオブジェクトのインターフェースを
+突き刺すのを妨げます。そのため、関数が裸の文字列の代わりに、オーバーロードされた
+オブジェクトを返すようになれば、あなたのテストは違いに気付かないでしょう。これは良いことです。
+
+=begin original
+
+However, it does mean that functions like is_deeply() cannot be used to
+test the internals of string overloaded objects.  In this case I would
+suggest L<Test::Deep> which contains more flexible testing functions for
+complex data structures.
+
+=end original
+
+ですが、is_deeply()のような関数が、オブジェクトがオーバーロードされた文字列の内部の
+テストに使うことが出来ないというわけではありません。このエースでは、
+L<Test::Deep>を提案します。複雑なデータ構造のために、より柔軟なテスト関数があります。
+
+
+=item Threads
+
+=begin original
+
+Test::More will only be aware of threads if "use threads" has been done
+I<before> Test::More is loaded.  This is ok:
+
+=end original
+
+Test::Moreは、Test::Moreがロードされる前に、"use threads"がされている場合、
+スレッドを意識します。次は ok です:
+
+
+    use threads;
+    use Test::More;
+
+=begin original
+
+This may cause problems:
+
+=end original
+
+次のものは問題になります:
+
+    use Test::More
+    use threads;
+
+=begin original
+
+5.8.1 and above are supported.  Anything below that has too many bugs.
+
+=end original
+
+5.8.1 以上を想定しています。それ未満のバージョンは、多くのバグがあります。
+
+=back
+
+
+=head1 HISTORY
+
+(経緯)
+
+=begin original
+
+This is a case of convergent evolution with Joshua Pritikin's Test
+module.  I was largely unaware of its existence when I'd first
+written my own ok() routines.  This module exists because I can't
+figure out how to easily wedge test names into Test's interface (along
+with a few other problems).
+
+=end original
+
+これは、Joshua Pritikin のテストモジュールをまとめて進化させたものです。
+自分のok()ルーチンを最初に書いたとき、Pritikinのテストモジュールの存在にまったく気づいていませんでした。
+このモジュールが在るのは、簡単にテストの名前をテストのインターフェースに、押し込む方法を見つけ出せなかったからです
+(他のいくつかの問題とともに)。
+
+=begin original
+
+The goal here is to have a testing utility that's simple to learn,
+quick to use and difficult to trip yourself up with while still
+providing more flexibility than the existing Test.pm.  As such, the
+names of the most common routines are kept tiny, special cases and
+magic side-effects are kept to a minimum.  WYSIWYG.
+
+=end original
+
+ここでのゴールは、存在するTest.pmより、柔軟性を提供しつつ
+学びやすく、すぐに使えて、つまずきにくいテストのユーティリティです。
+こんなわけで、ほとんどの共通のルーチンの名前は小さいままにして、
+特別なケースと魔法の側面の効果は最小限にとどめました。
+WYSIWYG（訳註:what you see is what you get）。
+
+
+=head1 SEE ALSO
+
+=begin original
+
+L<Test::Simple> if all this confuses you and you just want to write
+some tests.  You can upgrade to Test::More later (it's forward
+compatible).
+
+=end original
+
+L<Test::Simple> もし、Test::Moreがまったく混乱させるだけのものであり、
+ただ、テストを書きたいだけなら。後で、Test::Moreにアップグレードできます
+(Test::More は、上位互換性があります)。
+
+=begin original
+
+L<Test::Harness> is the test runner and output interpreter for Perl.
+It's the thing that powers C<make test> and where the C<prove> utility
+comes from.
+
+=end original
+
+L<Test::Harness>は、テストを実行機であり、Perlの出力インタプリタです。
+C<make test>に力を与えているものであり、C<prove>ユーティリティが
+由来するところです。
+
+=begin original
+
+L<Test::Legacy> tests written with Test.pm, the original testing
+module, do not play well with other testing libraries.  Test::Legacy
+emulates the Test.pm interface and does play well with others.
+
+=end original
+
+C<Test::Legacy>は、Test.pmと一緒に書かれた、オリジナルのテストモジュールです。
+他のテストライブラリと一緒にまうまく動きません。Test::Legacyは、
+Test.pmのインターフェースをエミュレートし、他のものとうまく動きます。
+
+=begin original
+
+L<Test::Differences> for more ways to test complex data structures.
+And it plays well with Test::More.
+
+=end original
+
+L<Test::Differences> 複雑なデータ構造をテストするためのより多くの方法のために。
+Test::Moreと一緒によくはたらきます。
+
+L<Test::Class> is like xUnit but more perlish.
+
+L<Test::Class> は、xUnitに似ていますが、より perlっぽいです。
+
+L<Test::Deep> gives you more powerful complex data structure testing.
+
+L<Test::Deep> は、より協力で複雑なデータ構造のテストができます。
+
+L<Test::Inline> shows the idea of embedded testing.
+
+L<Test::Inline>テストを埋め込む考えを見せます。
+
+L<Bundle::Test> installs a whole bunch of useful test modules.
+
+L<Bundle::Test> は、便利なテストもジュールを全部インストールします。
+
+=head1 AUTHORS
+
+Michael G Schwern E<lt>schwe****@pobox*****<gt> with much inspiration
+from Joshua Pritikin's Test module and lots of help from Barrie
+Slaymaker, Tony Bowden, blackstar.co.uk, chromatic, Fergal Daly and
+the perl-qa gang.
+
+=head1 BUGS
+
+See F<http://rt.cpan.org> to report and view bugs.
+
+
+=head1 SOURCE
+
+The source code repository for Test::More can be found at
+F<http://github.com/schwern/test-more/>.
+
+
+=head1 COPYRIGHT
+
+Copyright 2001-2008 by Michael G Schwern E<lt>schwe****@pobox*****<gt>.
+
+This program is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
Index: docs/modules/Test-Simple-0.99/lib/Test/Simple.pod
diff -u /dev/null docs/modules/Test-Simple-0.99/lib/Test/Simple.pod:1.1
--- /dev/null	Sun Nov 10 14:17:31 2013
+++ docs/modules/Test-Simple-0.99/lib/Test/Simple.pod	Sun Nov 10 14:17:31 2013
@@ -0,0 +1,411 @@
+=encoding utf8
+
+=head1 NAME
+
+=begin original
+
+Test::Simple - Basic utilities for writing tests.
+
+=end original
+
+
+Test::Simple - テストを書くための基本的なユーティリティ
+
+=head1 SYNOPSIS
+
+  use Test::Simple tests => 1;
+
+  ok( $foo eq $bar, 'foo is bar' );
+
+
+=head1 DESCRIPTION
+
+=begin original
+
+** If you are unfamiliar with testing B<read Test::Tutorial> first! **
+
+=end original
+
+** テストに馴染がないなら、まず、B<Test::Tutorialを読んで下さい>! **
+
+=begin original
+
+This is an extremely simple, extremely basic module for writing tests
+suitable for CPAN modules and other pursuits.  If you wish to do more
+complicated testing, use the Test::More module (a drop-in replacement
+for this one).
+
+=end original
+
+これは、CPANモジュールや、他の目的のためにテストを書くのに、
+極めて簡単な、極めて基本的なモジュールです。もし、より複雑なテストを望むなら、
+(置き換え可能な実装である)Test::Moreモジュールを使って下さい。
+
+=begin original
+
+The basic unit of Perl testing is the ok.  For each thing you want to
+test your program will print out an "ok" or "not ok" to indicate pass
+or fail.  You do this with the ok() function (see below).
+
+=end original
+
+Perlのテストの基本的なユニットは、okです。テストしたいものそれぞれについて、
+プログラムは、「ok」か、「not ok」を出力し、合格したか、失敗したかを示します。
+ok()関数で、これを行います(下を見てください)。
+
+=begin original
+
+The only other constraint is you must pre-declare how many tests you
+plan to run.  This is in case something goes horribly wrong during the
+test and your test program aborts, or skips a test or whatever.  You
+do this like so:
+
+=end original
+
+唯一の他の強制は、行おうと計画しているテストが、いくつであるかを先に宣言しなければならないことです。
+この宣言は、何かがテストの間に恐ろしい問題になり、テストのプログラムが中断するか、
+テストをスキップするか、何かそういったものが起こる場合のためにあります。このようにします：
+
+    use Test::Simple tests => 23;
+
+=begin original
+
+You must have a plan.
+
+=end original
+
+計画が必要です。
+
+=over 4
+
+=item B<ok>
+
+  ok( $foo eq $bar, $name );
+  ok( $foo eq $bar );
+
+=begin original
+
+ok() is given an expression (in this case C<$foo eq $bar>).  If it's
+true, the test passed.  If it's false, it didn't.  That's about it.
+
+=end original
+
+ok() には式が与えられています(この場合、C<$foo eq $bar>)。
+与えられた式が、真なら、テストは合格です。 与えられた式が、偽なら、合格ではありません。 
+だいたいそれくらいです。
+
+=begin original
+
+ok() prints out either "ok" or "not ok" along with a test number (it
+keeps track of that for you).
+
+=end original
+
+ok() は、テストの番号と一緒に、「ok」か「not ok」のどちらかを出力します
+(後を追い続けます)。
+
+  # This produces "ok 1 - Hell not yet frozen over" (or not ok)
+  ok( get_temperature($hell) > 0, 'Hell not yet frozen over' );
+
+=begin original
+
+If you provide a $name, that will be printed along with the "ok/not
+ok" to make it easier to find your test when if fails (just search for
+the name).  It also makes it easier for the next guy to understand
+what your test is for.  It's highly recommended you use test names.
+
+=end original
+
+もし、$nameを引数に与えるなら、$nameは、「ok/not ok」と一緒に出力され、
+テストが失敗した場合に、テストを見つけるのが簡単になります(だた名前だけで探せます)。
+また、こうしておけば、他の人が、あなたのテストが何のためにあるのかを理解するのが簡単になります。
+テストの名前を用いることは、強く推奨されます。
+
+=begin original
+
+All tests are run in scalar context.  So this:
+
+=end original
+
+全てのテストは、スカラーコンテキストで動きます。つまり、これは：
+
+    ok( @stuff, 'I have some stuff' );
+
+=begin original
+
+will do what you mean (fail if stuff is empty)
+
+=end original
+
+あなたの意図するように動きます（stuffが空なら失敗します）。
+
+=back
+
+=begin original
+
+Test::Simple will start by printing number of tests run in the form
+"1..M" (so "1..5" means you're going to run 5 tests).  This strange
+format lets Test::Harness know how many tests you plan on running in
+case something goes horribly wrong.
+
+=end original
+
+Test::Simple は、「1..M」と言う形式で、テストの動く番号をプリントすることで、
+始まります（つまり、「1..5」は、５つのテストを動かすという意味です）。
+この、変わったフォーマットは、何かが恐ろしく間違っているような場合に、
+実行中の計画がいくつあるかを、Test::Harnessに知らせます。
+
+=begin original
+
+If all your tests passed, Test::Simple will exit with zero (which is
+normal).  If anything failed it will exit with how many failed.  If
+you run less (or more) tests than you planned, the missing (or extras)
+will be considered failures.  If no tests were ever run Test::Simple
+will throw a warning and exit with 255.  If the test died, even after
+having successfully completed all its tests, it will still be
+considered a failure and will exit with 255.
+
+=end original
+
+もし、全てのテストが合格すれば、Test::Simpleは、0で、終えます(これは普通です)。
+何かが間違っていれば、間違ったか数で終了します。
+計画したのより、少ない（または、多くの）テストが実行された場合、見あたらないもの（か余分なもの）が
+あるため、計画は失敗したとみなされます。
+もし、テストが実行されなければ、Test::Simpleは、警告を投げて、
+255をで終えます。
+全てのテストがちゃんと完全にされた後でも、テストが死ねば
+それが、まだ失敗であると考えられ、255で終えます。
+
+=begin original
+
+So the exit codes are...
+
+=end original
+
+つまり、終了コードは…
+
+    0                   全てのテストが成功
+    255                 テストが死んだか全部通ったが何かおかしい # テストの実行について
+    any other number    いくつ失敗したか(足りないもの、余計なものを含む)
+
+=begin original
+
+If you fail more than 254 tests, it will be reported as 254.
+ 
+
+=end original
+
+254以上のテストが失敗した場合は、254として、報告されます。
+
+=begin original
+
+This module is by no means trying to be a complete testing system.
+It's just to get you started.  Once you're off the ground its
+recommended you look at L<Test::More>.
+
+=end original
+
+このモジュールは、決して、完全なテストシステムであろうとはしません。
+このモジュールは、ただ、あなたにテストを始めさせる切っ掛けにすぎません。
+一旦テストを始めたならば、L<Test::More>を見ることをお奨めします。
+
+=head1 EXAMPLE
+
+(例)
+
+=begin original
+
+Here's an example of a simple .t file for the fictional Film module.
+
+=end original
+
+架空のFilmモジュールのための簡単な、.t ファイルの例をあげます。
+
+    use Test::Simple tests => 5;
+
+    use Film;  # What you're testing.
+
+    my $btaste = Film->new({ Title    => 'Bad Taste',
+                             Director => 'Peter Jackson',
+                             Rating   => 'R',
+                             NumExplodingSheep => 1
+                           });
+    ok( defined($btaste) && ref $btaste eq 'Film',     'new() works' );
+
+    ok( $btaste->Title      eq 'Bad Taste',     'Title() get'    );
+    ok( $btaste->Director   eq 'Peter Jackson', 'Director() get' );
+    ok( $btaste->Rating     eq 'R',             'Rating() get'   );
+    ok( $btaste->NumExplodingSheep == 1,        'NumExplodingSheep() get' );
+
+=begin original
+
+It will produce output like this:
+
+=end original
+
+これは、このように出力します:
+
+    1..5
+    ok 1 - new() works
+    ok 2 - Title() get
+    ok 3 - Director() get
+    not ok 4 - Rating() get
+    #   Failed test 'Rating() get'
+    #   in t/film.t at line 14.
+    ok 5 - NumExplodingSheep() get
+    # Looks like you failed 1 tests of 5
+
+=begin original
+
+Indicating the Film::Rating() method is broken.
+
+=end original
+
+Film::Rating()メソッドが壊れている事を示しています。
+
+=head1 CAVEATS
+
+(警告)
+
+=begin original
+
+Test::Simple will only report a maximum of 254 failures in its exit
+code.  If this is a problem, you probably have a huge test script.
+Split it into multiple files.  (Otherwise blame the Unix folks for
+using an unsigned short integer as the exit status).
+
+=end original
+
+Test::Simpleは、その終了コードで、最大で254の失敗を報告するだけです。
+このことが問題になるのなら、おそらく、莫大なテストscriptなのでしょう。
+そのテストscriptを複数のファイルに分割して下さい。
+(もしくは、終了状態として、符号なしの短い整数を使うUNIXの人々を非難して下さい)
+
+=begin original
+
+Because VMS's exit codes are much, much different than the rest of the
+universe, and perl does horrible mangling to them that gets in my way,
+it works like this on VMS.
+
+=end original
+
+VMSの終了コードはそれ以外の世界とは、もっと、もっと違っており、
+自分のやり方を得ているPerlは恐ろしくその終了コードを押しつぶすので、
+VMSでは、次のように動きます。
+
+    0     SS$_NORMAL        全てのテストは成功
+    4     SS$_ABORT         何かが間違っています
+
+=begin original
+
+Unfortunately, I can't differentiate any further.
+
+=end original
+
+残念なことに、これ以上切り分けできません。
+
+=head1 NOTES
+
+(注意)
+
+=begin original
+
+Test::Simple is B<explicitly> tested all the way back to perl 5.6.0.
+
+=end original
+
+Test::Simpleは、perl 5.6.0 まで、B<はっきりと>テストされます。
+
+=begin original
+
+Test::Simple is thread-safe in perl 5.8.1 and up.
+
+=end original
+
+Test::Simple は、perl  5.8.1 以上で、スレッドセーフです。
+
+=head1 HISTORY
+
+(経緯)
+
+=begin original
+
+This module was conceived while talking with Tony Bowden in his
+kitchen one night about the problems I was having writing some really
+complicated feature into the new Testing module.  He observed that the
+main problem is not dealing with these edge cases but that people hate
+to write tests B<at all>.  What was needed was a dead simple module
+that took all the hard work out of testing and was really, really easy
+to learn.  Paul Johnson simultaneously had this idea (unfortunately,
+he wasn't in Tony's kitchen).  This is it.
+
+=end original
+
+このモジュールは、ある夜、Tony Bowden と一緒に、彼の家のキッチンで、
+私の抱えていた新しいテストのモジュールに本当に複雑な特徴を書くという問題について話している途中に、思いつきました。
+彼は、主な問題は、これらのエッジケースを処理することではなく、
+人々がテストを書くのを嫌っている事につきると見ていました。
+必要とされているのは、テストから、全てのきつい仕事を取り出した、実に、本当に、学びやすい、
+全く簡単なモジュールでした。Paul Johnsonは、同時にこのアイディアを持っていました(が、不幸なことに、かれは、Tonyのキッチンにいなかった)。
+これこそが、そのまったく簡単なテストのモジュールです。
+
+=head1 SEE ALSO
+
+=over 4
+
+=item L<Test::More>
+
+=begin original
+
+More testing functions!  Once you outgrow Test::Simple, look at
+Test::More.  Test::Simple is 100% forward compatible with Test::More
+(i.e. you can just use Test::More instead of Test::Simple in your
+programs and things will still work).
+
+=end original
+
+テストの機能がより多い！Test::Simpleを卒業したら、Test::Moreを見てください。
+Test::Simpleは、Test::Moreで、100%互換性があります。
+(たとえば、プログラムで、Test::Simpleの代わりに、Test::Moreを使うことが出来ますし、
+それはそのまま動きます。)
+
+=item L<Test>
+
+オリジナルのPerlのテストモジュール。
+
+=item L<Test::Unit>
+
+ユニットテストを入念にします。
+
+=item L<Test::Inline>, L<SelfTest>
+
+あなたのコード中に、テストを含めます!
+
+=item L<Test::Harness>
+
+テストプログラムの出力を解釈します。
+
+=back
+
+=begin original
+
+Look in Test::More's SEE ALSO for more testing modules.
+
+=end original
+
+Test::Moreの SEE ALSO には、より多くのテストモジュールがあります。
+
+
+=head1 AUTHORS
+
+Idea by Tony Bowden and Paul Johnson, code by Michael G Schwern
+E<lt>schwe****@pobox*****<gt>, wardrobe by Calvin Klein.
+
+=head1 COPYRIGHT
+
+Copyright 2001-2008 by Michael G Schwern E<lt>schwe****@pobox*****<gt>.
+
+This program is free software; you can redistribute it and/or 
+modify it under the same terms as Perl itself.
+
+See F<http://www.perl.com/perl/misc/Artistic.html>
Index: docs/modules/Test-Simple-0.99/lib/Test/Tutorial.pod
diff -u /dev/null docs/modules/Test-Simple-0.99/lib/Test/Tutorial.pod:1.1
--- /dev/null	Sun Nov 10 14:17:31 2013
+++ docs/modules/Test-Simple-0.99/lib/Test/Tutorial.pod	Sun Nov 10 14:17:31 2013
@@ -0,0 +1,1131 @@
+=encoding utf8
+
+=head1 NAME
+
+=begin original
+
+Test::Tutorial - A tutorial about writing really basic tests
+
+=end original
+
+Test::Tutorial - ごく基本的なテストを書くことについてのチュートリアル
+
+=head1 DESCRIPTION
+
+=begin original
+
+I<AHHHHHHH!!!!  NOT TESTING!  Anything but testing!
+Beat me, whip me, send me to Detroit, but don't make
+me write tests!>
+
+=end original
+
+I<あーーーーー!!!!テストは嫌! 何をおいてもテストは嫌!
+ぶっても、むち打っても、デトロイトに送ってもいいけど、
+テストを書かせないで!>
+
+=begin original
+
+I<*sob*>
+
+=end original
+
+I<*しくしく*>
+
+=begin original
+
+I<Besides, I don't know how to write the damned things.>
+
+=end original
+
+I<おまけに、そんな忌まわしいものの書き方など知りません。>
+
+=begin original
+
+Is this you?  Is writing tests right up there with writing
+documentation and having your fingernails pulled out?  Did you open up
+a test and read
+
+=end original
+
+あなたはこんな人ですか?
+テストを書くことは、ちょうど、ドキュメントを書き、指の爪を引き抜くことですか?
+テストを開き、読み、
+
+=begin original
+
+    ######## We start with some black magic
+
+=end original
+
+    ######## いくつかの黒魔術を始めます。
+
+
+=begin original
+
+and decide that's quite enough for you?
+
+=end original
+
+テストはもうたくさんだと判断しますか？
+
+=begin original
+
+It's ok.  That's all gone now.  We've done all the black magic for
+you.  And here are the tricks...
+
+=end original
+
+いいでしょう。全ては行ってしまいました。あなたのために、黒魔術をすべて行いました
+ここにその仕掛けがあります…
+
+=head2 Nuts and bolts of testing.
+
+(テストの基本)
+
+=begin original
+
+Here's the most basic test program.
+
+=end original
+
+最も基本的なテストのプログラム。
+
+    #!/usr/bin/perl -w
+
+    print "1..1\n";
+
+    print 1 + 1 == 2 ? "ok 1\n" : "not ok 1\n";
+
+=begin original
+
+Because 1 + 1 is 2, it prints:
+
+=end original
+
+1 + 1 は 2ですから、次のように表示します:
+
+    1..1
+    ok 1
+
+=begin original
+
+What this says is: C<1..1> "I'm going to run one test." [1] C<ok 1>
+"The first test passed".  And that's about all magic there is to
+testing.  Your basic unit of testing is the I<ok>.  For each thing you
+test, an C<ok> is printed.  Simple.  L<Test::Harness> interprets your test
+results to determine if you succeeded or failed (more on that later).
+
+=end original
+
+このコードの意味： C<1..1>[1]「一つのテストを行います。」C<ok 1>「最初のテストはパスしました」。 
+そして、これが、テストの魔法のほとんど全部です。基本的なユニットのテストはI<ok>です。
+L<Test::Harness>は、テストの結果を解釈し、成功したか失敗したかを判断します(後では、もっと判断します)。
+
+=begin original
+
+Writing all these print statements rapidly gets tedious.  Fortunately,
+there's L<Test::Simple>.  It has one function, C<ok()>.
+
+=end original
+
+これらのコードを全部書くのは、すぐに飽きてしまいます。
+ですが、幸運なことに、L<Test::Simple>があります。これには、C<ok()>という一つの関数があります。
+
+    #!/usr/bin/perl -w
+    
+    use Test::Simple tests => 1;
+    
+    ok( 1 + 1 == 2 );
+
+=begin original
+
+That does the same thing as the previous code.  C<ok()> is the backbone
+of Perl testing, and we'll be using it instead of roll-your-own from
+here on.  If C<ok()> gets a true value, the test passes.  False, it
+fails.
+
+=end original
+
+これは上のコードと同じことをします。C<ok()>は、Perlのテストの中心です。
+ここからは、自分で書く代わりに、C<ok()>を使います。
+C<ok()> が真を返せば、テストは合格です。偽であれば、失敗です.
+
+    #!/usr/bin/perl -w
+    
+    use Test::Simple tests => 2;
+    ok( 1 + 1 == 2 );
+    ok( 2 + 2 == 5 );
+
+=begin original
+
+From that comes:
+
+=end original
+
+このコードから、
+
+    1..2
+    ok 1
+    not ok 2
+    #     Failed test (test.pl at line 5)
+    # Looks like you failed 1 tests of 2.
+
+=begin original
+
+C<1..2> "I'm going to run two tests."  This number is a I<plan>. It helps to
+ensure your test program ran all the way through and didn't die or skip some
+tests.  C<ok 1> "The first test passed."  C<not ok 2> "The second test failed".
+Test::Simple helpfully prints out some extra commentary about your tests.
+
+=end original
+
+C<1..2> 「二つのテストを行います」
+この番号は、テストプログラムが最初から最後まで実行されたことを保証し、
+死んだり、いくつかのテストをスキップしたりしていないことも保証する助けになります。
+C<ok 1>「最初のテストはパスしました。」 C<not ok 2> 「2番目のテストは失敗しました」。
+Test::Simple はテストについての有用な特別のコメントを出力します。
+
+=begin original
+
+It's not scary.  Come, hold my hand.  We're going to give an example
+of testing a module.  For our example, we'll be testing a date
+library, L<Date::ICal>.  It's on CPAN, so download a copy and follow
+along. [2]
+
+=end original
+
+怖くはありませんよ。こっちへきて、手を取って。モジュールをテストする例をみせましょう。
+その例に、日付のライブラリである、B<Date::ICal>　をテストします。
+B<Date::ICal>は、CPANにありますので、コピーをダウンロードして、進んで下さい[2]。
+
+=head2 Where to start?
+
+(どこからはじめましょう?)
+
+=begin original
+
+This is the hardest part of testing, where do you start?  People often get
+overwhelmed at the apparent enormity of the task of testing a whole module.
+The best place to start is at the beginning.  C<Date::ICal> is an
+object-oriented module, and that means you start by making an object.  Test
+C<new()>.
+
+=end original
+
+ここがテストの一番難しいところです.どこからはじめましょう?
+モジュールの全てをテストすることは、明らかに大きな仕事であり、圧倒されます。
+最も良いのは、最初はからはじめることです.
+C<Date::ICal> は、オブジェクト指向のモジュールです。ですから、オブジェクトを作ることからはじめればいい。
+そう、C<new()>をテストしましょう。
+
+    #!/usr/bin/perl -w
+    
+    # assume these two lines are in all subsequent examples
+    use strict;
+    use warnings;
+    
+    use Test::Simple tests => 2;
+    
+    use Date::ICal;
+
+    my $ical = Date::ICal->new;         # オブジェクトを作成し
+    ok( defined $ical );                # 何かを得たかをテストし
+    ok( $ical->isa('Date::ICal') );     # そして、正しいクラスかテストします
+
+=begin original
+
+Run that and you should get:
+
+=end original
+
+これを実行すると、以下のようになります:
+
+    1..2
+    ok 1
+    ok 2
+
+=begin original
+
+Congratulations! You've written your first useful test.
+
+=end original
+
+おめでとう! 最初の有益なテストが書けました。
+
+=head2 Names
+
+(名前)
+
+=begin original
+
+That output isn't terribly descriptive, is it?  When you have two tests you can
+figure out which one is #2, but what if you have 102 tests?
+
+=end original
+
+この出力は、全然記述的じゃないですね?
+2つしかテストが無いなら、そのうちの一つが2番目のものだと分かりますが、
+102もテストがあったら、どうでしょう？
+
+=begin original
+
+Each test can be given a little descriptive name as the second
+argument to C<ok()>.
+
+=end original
+
+それぞれのテストには、ちょっとした記述的な名前を2番目の引数として、
+C<ok()>に与えることが出来ます。
+
+    use Test::Simple tests => 2;
+
+    ok( defined $ical,              'new() returned something' );
+    ok( $ical->isa('Date::ICal'),   "  and it's the right class" );
+
+=begin original
+
+Now you'll see:
+
+=end original
+
+今度は次のようになります:
+
+    1..2
+    ok 1 - new() returned something
+    ok 2 -   and it's the right class
+
+
+=head2 Test the manual
+
+(マニュアルのテスト)
+
+=begin original
+
+The simplest way to build up a decent testing suite is to just test what
+the manual says it does. [3] Let's pull something out of the
+L<Date::ICal/SYNOPSIS> and test that all its bits work.
+
+=end original
+
+もっとも簡単にきちんとしたテストを作る方法は、ただマニュアルに書かれていることをテストします[3]。
+L<Date::ICal/SYNOPSIS>から何かを引いてきて、それを全てテストしましょう。ちょっとしたことです。
+
+    #!/usr/bin/perl -w
+
+    use Test::Simple tests => 8;
+
+    use Date::ICal;
+
+    $ical = Date::ICal->new( year => 1964, month => 10, day => 16,
+                             hour => 16,   min   => 12, sec => 47,
+                             tz   => '0530' );
+
+    ok( defined $ical,            'new() returned something' );
+    ok( $ical->isa('Date::ICal'), "  and it's the right class" );
+    ok( $ical->sec   == 47,       '  sec()'   );
+    ok( $ical->min   == 12,       '  min()'   );
+    ok( $ical->hour  == 16,       '  hour()'  );
+    ok( $ical->day   == 17,       '  day()'   );
+    ok( $ical->month == 10,       '  month()' );
+    ok( $ical->year  == 1964,     '  year()'  );
+
+=begin original
+
+Run that and you get:
+
+=end original
+
+実行すると、次のようになります:
+
+    1..8
+    ok 1 - new() returned something
+    ok 2 -   and it's the right class
+    ok 3 -   sec()
+    ok 4 -   min()
+    ok 5 -   hour()
+    not ok 6 -   day()
+    #     Failed test (- at line 16)
+    ok 7 -   month()
+    ok 8 -   year()
+    # Looks like you failed 1 tests of 8.
+
+=begin original
+
+Whoops, a failure! [4] C<Test::Simple> helpfully lets us know on what line the
+failure occurred, but not much else.  We were supposed to get 17, but we
+didn't.  What did we get??  Dunno.  You could re-run the test in the debugger
+or throw in some print statements to find out.
+
+=end original
+
+おーっと、失敗![4] C<Test::Simple>は、役に立つことに、何行目で失敗したのかを知らせてくれます。
+けれど、他には何も知らせません。17を得なければならなかったのですが、そうはなりませんでした。何を得たのでしょうか??
+わかりません。それを見つけるには、デバッガーでテストを再実行しなければならいか、print文に投げなければなりません。
+
+=begin original
+
+Instead, switch from L<Test::Simple> to L<Test::More>.  C<Test::More>
+does everything C<Test::Simple> does, and more!  In fact, C<Test::More> does
+things I<exactly> the way C<Test::Simple> does.  You can literally swap
+C<Test::Simple> out and put C<Test::More> in its place.  That's just what
+we're going to do.
+
+=end original
+
+その代わりに、L<Test::Simple>から、L<Test::More>にきりかえましょう。
+C<Test::More> は、 C<Test::Simple>の行う全てのことを行えるし、もっと行えます!
+実際、Test::Moreは、C<Test::Simple>が行う方法をI<正確に>行います。
+文字通り、C<Test::Simple>を取り外し、C<Test::More>をそこに置くことが出来ます。
+ちょうど、やろうとしていることです。
+
+=begin original
+
+C<Test::More> does more than C<Test::Simple>.  The most important difference at
+this point is it provides more informative ways to say "ok".  Although you can
+write almost any test with a generic C<ok()>, it can't tell you what went
+wrong.  The C<is()> function lets us declare that something is supposed to be
+the same as something else:
+
+=end original
+
+C<Test::More> は、C<Test::Simple>より、働きます。最も重要な違いは、
+Test::Moreはより参考になるように「ok」と言う点です。
+一般的なC<ok()>でほとんどすべてのテストを書くことが出来ますが、
+C<ok()>では、何が間違っているのかわかりません。
+代わりに、C<is()>関数を使いましょう。C<is()>は、
+あるものが他のものと同じであると思われると私たちに宣言させます:
+
+
+    use Test::More tests => 8;
+
+    use Date::ICal;
+
+    $ical = Date::ICal->new( year => 1964, month => 10, day => 16,
+                             hour => 16,   min   => 12, sec => 47,
+                             tz   => '0530' );
+
+    ok( defined $ical,            'new() returned something' );
+    ok( $ical->isa('Date::ICal'), "  and it's the right class" );
+    is( $ical->sec,     47,       '  sec()'   );
+    is( $ical->min,     12,       '  min()'   );
+    is( $ical->hour,    16,       '  hour()'  );
+    is( $ical->day,     17,       '  day()'   );
+    is( $ical->month,   10,       '  month()' );
+    is( $ical->year,    1964,     '  year()'  );
+
+=begin original
+
+"Is C<$ical-E<gt>sec> 47?"  "Is C<$ical-E<gt>min> 12?"  With C<is()> in place,
+you get more information:
+
+=end original
+
+"C<$ical-E<gt>sec> は 47?"  "C<$ical-E<gt>min> は 12?"  代わりに、C<is()>を使うことで、
+より多くの情報を得ることができます:
+
+    1..8
+    ok 1 - new() returned something
+    ok 2 -   and it's the right class
+    ok 3 -   sec()
+    ok 4 -   min()
+    ok 5 -   hour()
+    not ok 6 -   day()
+    #     Failed test (- at line 16)
+    #          got: '16'
+    #     expected: '17'
+    ok 7 -   month()
+    ok 8 -   year()
+    # Looks like you failed 1 tests of 8.
+
+=begin original
+
+Aha. C<$ical-E<gt>day> returned 16, but we expected 17.  A
+quick check shows that the code is working fine, we made a mistake
+when writing the tests.  Change it to:
+
+=end original
+
+あは、C<$ical-E<gt>day>は、16を返しましたが、期待していたのは、17であったと知らせます。
+素早いチェックにより、このコードがうまく動くか、テストを書き上げたときにミスをしたかを示します。
+そこを変えましょう：
+
+    is( $ical->day,     16,       '  day()'   );
+
+=begin original
+
+... and everything works.
+
+=end original
+
+... これで、全部動きます。
+
+=begin original
+
+Any time you're doing a "this equals that" sort of test, use C<is()>.
+It even works on arrays.  The test is always in scalar context, so you
+can test how many elements are in an array this way. [5]
+
+=end original
+
+「これは、あれである」と言った種類のテストをするときはいつも、C<is>を使うといいです。
+C<is>は、配列でも働きます。ただ、テストは、つねに、スカラーコンテキストで動くので、
+次の方法で、配列の中の要素がいくつあるかをテストできます[5]。
+
+    is( @foo, 5, 'foo has 5 elements' );
+
+
+=head2 Sometimes the tests are wrong
+
+(テストは間違っている時もある)
+
+=begin original
+
+This brings up a very important lesson.  Code has bugs.  Tests are
+code.  Ergo, tests have bugs.  A failing test could mean a bug in the
+code, but don't discount the possibility that the test is wrong.
+
+=end original
+
+間違いは、とても大切なレッスンになります。コードにはバグがある。テストはコードである。
+ゆえに、テストにはバグがある。失敗したテストは、コードにバグがあることを意味します。
+しかし、テストが間違っている可能性を排除してはなりません。
+
+=begin original
+
+On the flip side, don't be tempted to prematurely declare a test
+incorrect just because you're having trouble finding the bug.
+Invalidating a test isn't something to be taken lightly, and don't use
+it as a cop out to avoid work.
+
+=end original
+
+反面、時期尚早に、ただ、バグを見つけるのに苦労しているからといって、
+テストが不正確であると断言しようという誘惑にかられないように。
+テストを無効にすることは、敏速にとれるものではありませんし、仕事から逃れて、避けるために、
+テストを無効にしてはいけません。
+
+=head2 Testing lots of values
+
+(たくさんの値のテスト)
+
+=begin original
+
+We're going to be wanting to test a lot of dates here, trying to trick
+the code with lots of different edge cases.  Does it work before 1970?
+After 2038?  Before 1904?  Do years after 10,000 give it trouble?
+Does it get leap years right?  We could keep repeating the code above,
+or we could set up a little try/expect loop.
+
+=end original
+
+多くの違ったエッジケースでコードをテストしようとするとき、多くの値をテストしたいと思います。
+1970年以前では、動くだろうか？2038年の後は？1904年以前は？10,000年後に、トラブルが起きるか？
+閏年を正しく得られるか？
+上のコードを繰り返し続けるか、ループを試みるかを、期待することが出来ます。
+
+    use Test::More tests => 32;
+    use Date::ICal;
+
+    my %ICal_Dates = (
+            # An ICal string     And the year, month, day
+            #                    hour, minute and second we expect.
+            '19971024T120000' =>    # from the docs.
+                                [ 1997, 10, 24, 12,  0,  0 ],
+            '20390123T232832' =>    # after the Unix epoch
+                                [ 2039,  1, 23, 23, 28, 32 ],
+            '19671225T000000' =>    # before the Unix epoch
+                                [ 1967, 12, 25,  0,  0,  0 ],
+            '18990505T232323' =>    # before the MacOS epoch
+                                [ 1899,  5,  5, 23, 23, 23 ],
+    );
+
+
+    while( my($ical_str, $expect) = each %ICal_Dates ) {
+        my $ical = Date::ICal->new( ical => $ical_str );
+
+        ok( defined $ical,            "new(ical => '$ical_str')" );
+        ok( $ical->isa('Date::ICal'), "  and it's the right class" );
+
+        is( $ical->year,    $expect->[0],     '  year()'  );
+        is( $ical->month,   $expect->[1],     '  month()' );
+        is( $ical->day,     $expect->[2],     '  day()'   );
+        is( $ical->hour,    $expect->[3],     '  hour()'  );
+        is( $ical->min,     $expect->[4],     '  min()'   );
+        is( $ical->sec,     $expect->[5],     '  sec()'   );
+    }
+
+=begin original
+
+Now we can test bunches of dates by just adding them to
+C<%ICal_Dates>.  Now that it's less work to test with more dates, you'll
+be inclined to just throw more in as you think of them.
+Only problem is, every time we add to that we have to keep adjusting
+the C<use Test::More tests =E<gt> ##> line.  That can rapidly get
+annoying.  There are ways to make this work better.
+
+=end original
+
+今や、ただ、C<%ICal_Dates>に日付の束を加えるだけで、テストできます。
+さて、たくさんの日付をテストするのが少ない仕事になりましたが、
+考えるように、ただ、日付を投げるだけにしたいかもしれません。
+唯一の問題は、毎回、C<use Test::More tests =E<gt> ##> の行を、調節しなければならない事です。
+このことは、急速に煩雑になるでしょう。いくつかの方法で、もっとうまくやれます。
+
+=begin original
+
+First, we can calculate the plan dynamically using the C<plan()>
+function.
+
+=end original
+
+一つめの方法は、C<plan()>関数を動的に使って、計画を計算します。
+
+    use Test::More;
+    use Date::ICal;
+
+    my %ICal_Dates = (
+        ...same as before...
+    );
+
+    # For each key in the hash we're running 8 tests.
+    plan tests => keys(%ICal_Dates) * 8;
+
+    ...and then your tests...
+
+=begin original
+
+To be even more flexible, use C<done_testing>.  This means we're just
+running some tests, don't know how many. [6]
+
+=end original
+
+よりフレキシブルに、C<done_testing> を使います。これにより、
+いくつかのテストをただ走らせます。いくつなのかは知りません[6]。
+
+    use Test::More;   # instead of tests => 32
+
+    ... # tests here
+
+    done_testing();   # reached the end safely
+
+=begin original
+
+If you don't specify a plan, C<Test::More> expects to see C<done_testing()>
+before your program exits. It will warn you if you forget it. You can give
+C<done_testing()> an optional number of tests you expected to run, and if the
+number ran differs, C<Test::More> will give you another kind of warning.
+
+=end original
+
+プランを特定しないと、C<Test::More>は、プログラムが終了する前に、
+C<done_testing()>があると期待します。もし、書き忘れていれば警告します。
+C<done_testing()>に、実行される予定のテストの数を渡すこともできます。
+動いた数が違っていれば、C<Test::More>は、別の種類の警告が出ます。
+
+=head2 Informative names
+
+(有益な名前)
+
+=begin original
+
+Take a look at the line:
+
+=end original
+
+次の行をみてください
+
+
+    ok( defined $ical,            "new(ical => '$ical_str')" );
+
+=begin original
+
+We've added more detail about what we're testing and the ICal string
+itself we're trying out to the name.  So you get results like:
+
+=end original
+
+テストしていることと、テストしている ICal ストリング自身の詳細を、名前に加えます。
+次のような結果が出ます：
+
+    ok 25 - new(ical => '19971024T120000')
+    ok 26 -   and it's the right class
+    ok 27 -   year()
+    ok 28 -   month()
+    ok 29 -   day()
+    ok 30 -   hour()
+    ok 31 -   min()
+    ok 32 -   sec()
+
+=begin original
+
+If something in there fails, you'll know which one it was and that
+will make tracking down the problem easier.  Try to put a bit of
+debugging information into the test names.
+
+=end original
+
+失敗の中に何かあるなら、それが一つであり、それによって、問題を追跡するのが簡単になることがわかるでしょう。
+ちょっとしたデバッグ情報をテストの名前に入れてみて下さい。
+
+=begin original
+
+Describe what the tests test, to make debugging a failed test easier
+for you or for the next person who runs your test.
+
+=end original
+
+そのテストが何をテストするかを記述しておけば、
+失敗したテストをデバッグする際、自分や他の人がテストを実行するのが、簡単になります。
+
+=head2 Skipping tests
+
+(テストをスキップする)
+
+=begin original
+
+Poking around in the existing Date::ICal tests, I found this in
+F<t/01sanity.t> [7]
+
+=end original
+
+Date::ICal で用意されているテストを探し回って、F<t/01sanity.t>に、次のものを見つけました[7]。
+
+    #!/usr/bin/perl -w
+
+    use Test::More tests => 7;
+    use Date::ICal;
+
+    # Make sure epoch time is being handled sanely.
+    my $t1 = Date::ICal->new( epoch => 0 );
+    is( $t1->epoch, 0,          "Epoch time of 0" );
+
+    # XXX This will only work on unix systems.
+    is( $t1->ical, '19700101Z', "  epoch to ical" );
+
+    is( $t1->year,  1970,       "  year()"  );
+    is( $t1->month, 1,          "  month()" );
+    is( $t1->day,   1,          "  day()"   );
+
+    # like the tests above, but starting with ical instead of epoch
+    my $t2 = Date::ICal->new( ical => '19700101Z' );
+    is( $t2->ical, '19700101Z', "Start of epoch in ICal notation" );
+
+    is( $t2->epoch, 0,          "  and back to ICal" );
+
+=begin original
+
+The beginning of the epoch is different on most non-Unix operating systems [8].
+Even though Perl smooths out the differences for the most part, certain ports
+do it differently.  MacPerl is one off the top of my head. [9]  Rather than
+putting a comment in the test and hoping someone will read the test while
+debugging the failure, we can explicitly say it's never going to work and skip
+the test.
+
+=end original
+
+たいていの非UNIX OS では、エポックの始まりが異なっています[8]。
+ほとんどの部分でPerlは、差異をならしていますが、ある部分では、違ったように行います。
+今、正確には思い出せませんが、MacPerlはその一つだと思います[9]。
+ただテストにコメントを書いて、失敗をデバッグしている間に、誰かがテスト読むことを
+期待するよりも、はっきりと、決して働かないように言い、テストをスキップすることが出来ます。
+
+    use Test::More tests => 7;
+    use Date::ICal;
+
+    # Make sure epoch time is being handled sanely.
+    my $t1 = Date::ICal->new( epoch => 0 );
+    is( $t1->epoch, 0,          "Epoch time of 0" );
+
+    SKIP: {
+        skip('epoch to ICal not working on Mac OS', 6)
+            if $^O eq 'MacOS';
+
+        is( $t1->ical, '19700101Z', "  epoch to ical" );
+
+        is( $t1->year,  1970,       "  year()"  );
+        is( $t1->month, 1,          "  month()" );
+        is( $t1->day,   1,          "  day()"   );
+
+        # like the tests above, but starting with ical instead of epoch
+        my $t2 = Date::ICal->new( ical => '19700101Z' );
+        is( $t2->ical, '19700101Z', "Start of epoch in ICal notation" );
+
+        is( $t2->epoch, 0,          "  and back to ICal" );
+    }
+
+
+=begin original
+
+A little bit of magic happens here.  When running on anything but MacOS, all
+the tests run normally.  But when on MacOS, C<skip()> causes the entire
+contents of the SKIP block to be jumped over.  It never runs.  Instead,
+C<skip()> prints special output that tells C<Test::Harness> that the tests have
+been skipped.
+
+=end original
+
+ここで、ちょっとした魔法が起きます。
+MacOS以外で動いた場合,全てのテストは普通にテストされます。
+しかし、MacOS上の場合、C<skip()>によって、SKIPブロックの中の全ての内容が飛ばされます。
+決して動くことはありません。
+かわりに、C<skip()>はテストがスキップされていることをTest::Harness に伝える特別な出力をプリントします。
+
+    1..7
+    ok 1 - Epoch time of 0
+    ok 2 # skip epoch to ICal not working on MacOS
+    ok 3 # skip epoch to ICal not working on MacOS
+    ok 4 # skip epoch to ICal not working on MacOS
+    ok 5 # skip epoch to ICal not working on MacOS
+    ok 6 # skip epoch to ICal not working on MacOS
+    ok 7 # skip epoch to ICal not working on MacOS
+
+=begin original
+
+This means your tests won't fail on MacOS.  This means fewer emails
+from MacPerl users telling you about failing tests that you know will
+never work.  You've got to be careful with skip tests.  These are for
+tests which don't work and I<never will>.  It is not for skipping
+genuine bugs (we'll get to that in a moment).
+
+=end original
+
+これは、MacOS上で,テストは失敗しないという意味です。
+これで、MacPerlのユーザーからの、動かないと分かっているテストが動かないと報告するemailがより少なくなります。
+テストのスキップについて慎重になるように。スキップのテストは、動かない、I<決して動かない>テストに対してあるものです。
+本物のバグをスキップする為のものではありません(すぐにそうなるでしょう)。
+
+=begin original
+
+The tests are wholly and completely skipped. [10]  This will work.
+
+=end original
+
+このテストは、まったく、完全にスキップされます[10]。以下のコードは、動きます。
+
+    SKIP: {
+        skip("I don't wanna die!");
+
+        die, die, die, die, die;
+    }
+
+
+=head2 Todo tests
+
+(ToDo テスト)
+
+=begin original
+
+While thumbing through the C<Date::ICal> man page, I came across this:
+
+=end original
+
+C<Date::ICal>のmanページをざっと目を通していて、次のものに遭遇しました:
+
+   ical
+
+       $ical_string = $ical->ical;
+
+   オブジェクトの日付の取得、または、セット。
+   すべての妥当な ICal date/time 文字列を使って、オブジェクトに日付をセットする。
+
+=begin original
+
+"Retrieves or sets".  Hmmm. I didn't see a test for using C<ical()> to set
+the date in the Date::ICal test suite.  So I wrote one:
+
+=end original
+
+「取得またはセット」。ふむ、Date::ICalのテストで、日付をセットするC<ical()> を使うテストを見ませんでした。
+私は、次のように書くでしょう。
+
+    use Test::More tests => 1;
+    use Date::ICal;
+
+    my $ical = Date::ICal->new;
+    $ical->ical('20201231Z');
+    is( $ical->ical, '20201231Z',   'Setting via ical()' );
+
+=begin original
+
+Run that. I saw:
+
+=end original
+
+これを実行すると:
+
+    1..1
+    not ok 1 - Setting via ical()
+    #     Failed test (- at line 6)
+    #          got: '20010814T233649Z'
+    #     expected: '20201231Z'
+    # Looks like you failed 1 tests of 1.
+
+=begin original
+
+Whoops!  Looks like it's unimplemented.  Assume you don't have the time to fix
+this. [11] Normally, you'd just comment out the test and put a note in a todo
+list somewhere.  Instead, explicitly state "this test will fail" by wrapping it
+in a C<TODO> block:
+
+=end original
+
+おーっと! 実行されないようだ。さて、これを修正する時間がないと想定しましょう。[11]
+ふつうは、このテストをコメントにして、ToDoリストに書き留めておくでしょう。
+その代わりに、C<TODO>ブロック内でラッピングして（包んで）、「このテストが失敗した」という明らかな状態にしましょう。
+
+    use Test::More tests => 1;
+
+    TODO: {
+        local $TODO = 'ical($ical) not yet implemented';
+
+        my $ical = Date::ICal->new;
+        $ical->ical('20201231Z');
+
+        is( $ical->ical, '20201231Z',   'Setting via ical()' );
+    }
+
+=begin original
+
+Now when you run, it's a little different:
+
+=end original
+
+実行すると、ちょっとした違いがあります：
+
+    1..1
+    not ok 1 - Setting via ical() # TODO ical($ical) not yet implemented
+    #          got: '20010822T201551Z'
+    #     expected: '20201231Z'
+
+=begin original
+
+C<Test::More> doesn't say "Looks like you failed 1 tests of 1".  That '#
+TODO' tells C<Test::Harness> "this is supposed to fail" and it treats a
+failure as a successful test.  You can write tests even before
+you've fixed the underlying code.
+
+=end original
+
+C<Test::More>は、「一つのテストの中の一つが失敗したようだ」とは言いません。
+この「# TODO」は、C<Test::Harness> に「これは、失敗すると思われる」と伝え、
+C<Test::Harness>は、失敗したテストを成功したテストのように扱います。これで、
+バグを修正する前にテストを書くことができます。
+
+=begin original
+
+If a TODO test passes, C<Test::Harness> will report it "UNEXPECTEDLY
+SUCCEEDED".  When that happens, remove the TODO block with C<local $TODO> and
+turn it into a real test.
+
+=end original
+
+もし、TODOテストがパスすると、Test::Harness は、テストが、「思いがけず成功した」と報告します。
+これが起きれば、C<local $TODO>でTODOブロックを外して、本当のテストに変えれば良いでしょう。
+
+
+=head2 Testing with taint mode.
+
+(汚染モードでのテスト)
+
+=begin original
+
+Taint mode is a funny thing.  It's the globalest of all global
+features.  Once you turn it on, it affects I<all> code in your program
+and I<all> modules used (and all the modules they use).  If a single
+piece of code isn't taint clean, the whole thing explodes.  With that
+in mind, it's very important to ensure your module works under taint
+mode.
+
+=end original
+
+汚染モードは楽しいものです。全ての全体的な特徴のなかでも、もっとも全体的なものです。
+汚染モードを付けると、汚染モードは、プログラムの全てのコードとI<全ての>モジュール
+(と、それらが使っているI<全ての>モジュール)に影響します。
+コードの一つでも、汚染されていれば、全てが爆発します。
+このことを念頭に置いて、汚染モードの下で、モジュールが動くのを保証することは、とても重要です。
+
+=begin original
+
+It's very simple to have your tests run under taint mode.  Just throw
+a C<-T> into the C<#!> line.  C<Test::Harness> will read the switches
+in C<#!> and use them to run your tests.
+
+=end original
+
+テストを、汚染モードで走らせるのは、とても簡単です。
+C<#!>行に、C<-T>を投げるだけです。C<Test::Harness> は、
+C<#!> 行のスイッチを読み、テストでそのスイッチを使います。
+
+
+    #!/usr/bin/perl -Tw
+
+    ...test normally here...
+
+=begin original
+
+When you say C<make test> it will run with taint mode on.
+
+=end original
+
+C<make test>をすると、テストは汚染モードと警告を有効にして走るでしょう。
+
+=head1 FOOTNOTES
+
+(脚注)
+
+=over 4
+
+=item 1
+
+=begin original
+
+The first number doesn't really mean anything, but it has to be 1.
+It's the second number that's important.
+
+=end original
+
+最初の数字は実際何も意味していませんが、1でなければいけません。
+重要なのは、2番目の数字です。
+
+=item 2
+
+=begin original
+
+For those following along at home, I'm using version 1.31.  It has
+some bugs, which is good -- we'll uncover them with our tests.
+
+=end original
+
+以下に進むため、バージョン1.31を使います。このバージョンには、バグが少々ありますが、
+大丈夫です -- テストでバグを明らかにしましょう。
+
+=item 3
+
+=begin original
+
+You can actually take this one step further and test the manual
+itself.  Have a look at L<Test::Inline> (formerly L<Pod::Tests>).
+
+=end original
+
+実際に、このステップをもっと取り入れ、マニュアル自身をテストできます。
+L<Test::Inline>を見なさい。 (以前の L<Pod::Tests>)
+
+=item 4
+
+=begin original
+
+Yes, there's a mistake in the test suite.  What!  Me, contrived?
+
+=end original
+
+このテストには、間違いがあります。何! 私が、仕組んだって？
+
+=item 5
+
+=begin original
+
+We'll get to testing the contents of lists later.
+
+=end original
+
+後で、リストの内容をテストします。
+
+=item 6
+
+=begin original
+
+But what happens if your test program dies halfway through?!  Since we
+didn't say how many tests we're going to run, how can we know it
+failed?  No problem, C<Test::More> employs some magic to catch that death
+and turn the test into a failure, even if every test passed up to that
+point.
+
+=end original
+
+しかし、テストプログラムが途中で死んだら、何が起きるのだろうか?!
+どれくらいのテストを動かしているのか書かないで、どうやって失敗したのかわかるだろうか?
+問題ありません。C<Test::More>は、いくつかの魔法を使い、その死を捕らえ、
+テストを失敗に変えます。たとえ、全てのテストが、その場所でパスしたとしても。
+
+=item 7
+
+=begin original
+
+I cleaned it up a little.
+
+=end original
+
+ちょっとだけ綺麗にしました。
+
+=item 8
+
+=begin original
+
+Most Operating Systems record time as the number of seconds since a
+certain date.  This date is the beginning of the epoch.  Unix's starts
+at midnight January 1st, 1970 GMT.
+
+=end original
+
+たいていのOSは、ある日付からの秒数として時間を記録します。
+この日付が、エポックの始まりです。UNIXのエポックの始まりは、標準時の1970年の1月1日の深夜です。
+
+=item 9
+
+=begin original
+
+MacOS's epoch is midnight January 1st, 1904.  VMS's is midnight,
+November 17th, 1858, but vmsperl emulates the Unix epoch so it's not a
+problem.
+
+=end original
+
+MacOSのエポックは、1904年の1月1日の深夜です。VMSのエポックは、1858年の11月17日の深夜です。
+ですが、vmsperlは、UNIXのエポックをエミュレートしているので、問題はありません。
+
+=item 10
+
+=begin original
+
+As long as the code inside the SKIP block at least compiles.  Please
+don't ask how.  No, it's not a filter.
+
+=end original
+
+SKIPブロックの中にコードが在る限り、少なくともコンパイルされます。どうやってるかは聞かないで下さい。
+フィルターではありません。
+
+=item 11
+
+=begin original
+
+Do NOT be tempted to use TODO tests as a way to avoid fixing simple
+bugs!
+
+=end original
+
+簡単なバグを直すのを避けるための方法として、TODOテストを使おうとしてはいけません!
+
+=back
+
+=head1 AUTHORS
+
+Michael G Schwern E<lt>schwe****@pobox*****<gt> and the perl-qa dancers!
+
+=head1 COPYRIGHT
+
+Copyright 2001 by Michael G Schwern E<lt>schwe****@pobox*****<gt>.
+
+This documentation is free; you can redistribute it and/or modify it
+under the same terms as Perl itself.
+
+Irrespective of its distribution, all code examples in these files
+are hereby placed into the public domain.  You are permitted and
+encouraged to use this code in your own programs for fun
+or for profit as you see fit.  A simple comment in the code giving
+credit would be courteous but is not required.
+
+
+=cut

• 前の記事 [perldocjp-cvs 1836] CVS update: docs/modules/Test-Simple-0.99/lib/Test
• 次の記事 [perldocjp-cvs 1837] CVS update: docs/modules/Test-Simple-0.99/lib/Test
• 記事の並び順: [ 日付 ] [ スレッド ] [ 件名 ] [ 著者 ]