[from now] 2013/03/26 08:29:44

diff --git a/docs/locale/ja/LC_MESSAGES/interaction_based_testing.mo b/docs/locale/ja/LC_MESSAGES/interaction_based_testing.mo
index 0149855..050354f 100644
Binary files a/docs/locale/ja/LC_MESSAGES/interaction_based_testing.mo and b/docs/locale/ja/LC_MESSAGES/interaction_based_testing.mo differ
diff --git a/docs/locale/ja/LC_MESSAGES/interaction_based_testing.po b/docs/locale/ja/LC_MESSAGES/interaction_based_testing.po
index 401774f..6ab5450 100644
--- a/docs/locale/ja/LC_MESSAGES/interaction_based_testing.po
+++ b/docs/locale/ja/LC_MESSAGES/interaction_based_testing.po
@@ -34,7 +34,8 @@ msgstr ""
 "相互作用中心のテストは2000年代前半に登場したExtreme Programming(XP)"
 "から生まれた設計、テストの手法です。"
 "オブジェクトの状態ではなく振る舞いに注目し、メソッドを呼び出した際に"
-"コラボレータと共にオブジェクトが意図したとおりに相互作用するか検証します。"
+"コラボレータとオブジェクトの間で、意図したとインタラクション(相互作用)"
+"が行われるか検証します。"

 # debfa7f02af44cb6a423fd0a260359be
 #: ../../interaction_based_testing.rst:10
@@ -73,10 +74,10 @@ msgid ""
 "generate mock implementations of collaborators that verify these "
 "expectations."
 msgstr ""
-"subscriberのモック実装を開発者自身で用意することもできますが、相互作用が複雑な"
+"subscriberのモック実装を開発者自身で用意することもできますが、インタラクションが複雑な"
 "メソッドが増えてくると、非常に手間になってきます。そこでモックフレームワーク"
 "の登場です。このフレームワークはコラボレータがどのように"
-"相互作用すべきか定義でき、その定義どおりに動作したか検証できます。"
+"インタラクションすべきか定義することで、実際にその通りに動作したか検証できます。"

 # 24e8bec5a9bd4c10bdeff0a92bc789ce
 #: ../../interaction_based_testing.rst:38
@@ -89,9 +90,9 @@ msgid ""
 "code."
 msgstr ""
 "よくあるJavaのモックフレームワークと同様に、Spockも"
-"\\ `JDK動的プロキシ <http://docs.oracle.com/javase/7/docs/api/>`_\\ (インタフェースのモックする時)"
-"、\\ `CGLIB <http://cglib.sourceforge.net>`_\\ プロキシ(クラスをモックする時)を使用してモックを"
-"作成します。これらは、Groovyのメタプラグラミングを使用した場合にくらべ、Javaで"
+"\\ `JDK動的プロキシ <http://docs.oracle.com/javase/7/docs/api/>`_\\ (インタフェースのモック時)"
+"、\\ `CGLIB <http://cglib.sourceforge.net>`_\\ プロキシ(クラスをモック時)を使用してモックを"
+"作成します。これらは、Groovyのメタプラグラミングを使用した場合に比べ、Javaのコードで"
 "モックを使用する際に有利に働きます。"

 # d0dd89c9f6b144b0b02acbb9aa9f1181
@@ -112,8 +113,8 @@ msgstr ""
 "\\ `Mockito <http://code.google.com/p/mockito/>`_\\ といったモックフレームワークが人気があり、"
 "非常に成熟しています。これらのモックフレームワークをSpcokで使用することもできますが、"
 "Spcokの言語仕様に合わせてより自然に記述できるように、モックフレームワークを"
-"Spock自身で再構築することを決めました。この判断は、相互作用中心の"
-"テストを容易にするため、Groovyの機能を活用して、より読みやすく、より楽しく書けるよう"
+"Spock自身で再構築することを決めました。この判断は、インタラクション中心の"
+"テストを容易にするため、Groovyの機能を活用し、より読みやすく、より楽しく書けるよう"
 "にしたいという思いからです。"
 "この章を読み終えた時に、その目標が達成されていると感じていただけると幸いです。"

@@ -174,7 +175,7 @@ msgid ""
 msgstr ""
 "モックオブジェクトは文字通りその型の実装(クラスの場合はサブクラス)を作成します。"
 "別の言い方をすると、上記の例でsubscriberはis-a Subscriberです。"
-"これは、この型を期待する静的型付けのコード(Java)に"
+"これは、この型を期待する静的型付けのコード(Java)に、"
 "このオブジェクトを渡せることを意味しています。"

 # 92b15d3b0c0d44d8a26f37dffc24ea58
@@ -196,16 +197,17 @@ msgid ""
 "describe only what's relevant about an interaction, avoiding the over-"
 "specification trap."
 msgstr ""
+"(質問: Lenient/Strictなモックフレームワーク) "
 "Mockitのように、モックフレームはデフォルトでlenient(緩い)であるべきだと考えています。"
 "これはモックオブジェクトに対して予期しないメソッド(別の言い方をすると、"
-"テストと関係のない相互作用)の呼び出しを許容し、"
+"テストと関係のないインタラクション)の呼び出しを許容し、"
 "その呼び出しに対しデフォルトのレスポンスを返すことを意味します。"
 "逆にEasyMock、JMockといったモックフレームはデフォルトでstrictで、"
 "予期しないメソッドの呼び出しに対し、例外をスローします。"
 "このような厳密性の強制は、内部のコード変更に対してテストが壊れやすくなり、"
 "すぐにテストが失敗する、over-specification(詳細すぎる仕様)を引き起こします。"
 "Spockはモックフレームワークによくあるover-specificationを避け、"
-"関心のある相互作用だけに集中できます。"
+"関心のあるインタラクションだけに集中できます。"

 # cf77246bfb6441debd3f255bf615b39f
 #: ../../interaction_based_testing.rst:86
@@ -248,13 +250,13 @@ msgid ""
 "We are now ready to describe the expected interactions between the two "
 "parties."
 msgstr ""
-"これで２つのオブジェクト間で行われる相互作用について記述する"
+"これで2つのオブジェクト間で行われるインタラクションについて記述する"
 "準備が整いました。"

 # 6e9b615a816a46e6a3aff1e3c4129e74
 #: ../../interaction_based_testing.rst:111
 msgid "Mocking"
-msgstr "モックする"
+msgstr "モッキング(Mocking)"

 # be2452128cb34aca894ac477050b5496
 #: ../../interaction_based_testing.rst:113
@@ -262,8 +264,8 @@ msgid ""
 "Mocking is the act of describing (mandatory) interactions between the object "
 "under specification and its collaborators. Here is an example::"
 msgstr ""
-"モックするとは、仕様に従いオブジェクトとそのコラボレータ間(で必須)の"
-"相互作用を宣言するということです。"
+"モッキングとは、オブジェクトとそのコラボレータ間(で必須)の、"
+"インタラクションを定義するということです。"
 "次の例を見てください。"

 # b8109a44526043bfb0a9c3b825217ca3
@@ -285,17 +287,17 @@ msgid ""
 "thrown. This verification happens automatically and does not require any "
 "additional code."
 msgstr ""
-"フィーチャーメソッドが実行されると、\\ ``when:``\\ ブロック内において"
-"\\ ``then:``\\ ブロックで指定した相互作用にマッチする"
+"フィーチャーメソッドが実行されると、\\ ``then:``\\ ブロックで宣言した"
+"インタラクションにマッチする、\\ ``when:``\\ ブロックでの"
 "モックオブジェクトへの呼び出しが全て記録されます。"
-"もし期待した相互作用が満たされない場合は\\ ``InteractionNotSatisfiedError``\\ "
+"もし期待したインタラクションが満たされない場合は\\ ``InteractionNotSatisfiedError``\\ "
 "(のサブクラス)がスローされます。"
-"この検証は自動的に行われ、これ以上に開発者自身でコードを記述する必要はありません。"
+"この検証は自動的に行われ、開発者自身で検証のコードを記述する必要はありません。"

 # be33d88d5f3141f497456c847fc5da94
 #: ../../interaction_based_testing.rst:133
 msgid "Interactions"
-msgstr "相互作用"
+msgstr "インタラクション"

 # 27703cd55f37403d907950416aa5d7e1
 #: ../../interaction_based_testing.rst:137
@@ -307,13 +309,13 @@ msgid ""
 "against. Depending on the circumstances, the interaction may match zero, "
 "one, or multiple invocations."
 msgstr ""
-"(質問：相互作用は通常のメソッド呼び出しか？)"
-"いいえ。相互作用は通常のメソッド呼び出しのように見えますが、"
-"これは期待するメソッドの実行回数を簡単に表現しているだけです。"
-"相互作用をモックオブジェクトの全ての呼び出しに対する正規表現と"
-"考えるのと良いかもしれません。"
-"指定の方法によっては相互作用が０回、１回、または複数回マッチする"
-"といった表現ができます。"
+"(質問: インタラクションは通常のメソッド呼び出しか？) "
+"いいえ。インタラクションは通常のメソッド呼び出しのように見えますが、"
+"これは呼び出しを期待するメソッドの多重度が、わかりやすいように表現しているにすぎません。"
+"またインタラクションを、モックオブジェクトの全ての呼び出しに対する、正規表現と"
+"考えるのとわかりやすいかもしれません。"
+"指定の方法によってインタラクションが0回、1回、または複数回マッチする"
+"といった表現が可能です。"

 # d496b838aad345629eea4eb09cf0a80c
 #: ../../interaction_based_testing.rst:142
@@ -322,16 +324,16 @@ msgid ""
 "*interactions*, each of which has four distinct parts: a *cardinality*, a "
 "*target constraint*, a *method constraint*, and an *argument constraint*::"
 msgstr ""
-"``then:``\\ ブロックの内容を詳細に見ていきましょう。"
-"これには２つの\\ *相互作用*\\ が宣言されており、それぞれ"
-"\\ *実行回数(cardinality)*\\ 、\\ *対象制約(target constraint)*\\ 、"
+"``then:``\\ ブロックの詳細を見ていきます。"
+"上記では2つの\\ *インタラクション*\\ を定義していますが、それぞれ"
+"\\ *多重度(cardinality)*\\ 、\\ *対象制約(target constraint)*\\ 、"
 "\\ *メソッド制約(method constraint)*\\ 、そして\\ *引数制約(argument constraint)*\\ "
-"の４つの個別パートから成り立っています。"
+"の4つの個別パートから成り立っています。"

 # e81001af510f4785ab5bfaeb5f3f5358
 #: ../../interaction_based_testing.rst:153
 msgid "Cardinality"
-msgstr "実行回数"
+msgstr "多重度"

 # 97b577ab60bf4adca010687ef58d4f33
 #: ../../interaction_based_testing.rst:155
@@ -339,7 +341,7 @@ msgid ""
 "The cardinality of an interaction describes how often a method call is "
 "expected. It can either be a fixed number or a range::"
 msgstr ""
-"実行回数は、メソッドが何度呼ばされることを期待しているか表しています。"
+"多重度は期待するメソッドの呼び出し回数を表しています。"
 "これは固定の数値、または範囲で指定できます。"

 # f9b110fd388d4db0b4b7cbf2fc64ef28
@@ -374,15 +376,14 @@ msgid ""
 "When expecting a call to a getter method, Groovy property syntax *can* be "
 "used instead of method syntax::"
 msgstr ""
-"ゲッターメソッドの呼び出しを期待する場合は、Groovyのプロパティ構文が"
-"メソッドの構文の代わりに使用できます。"
+"呼び出しを期待するメソッドがゲッターの場合は、Groovyのプロパティ構文が使用できます。"

 # e00d2250ebc347c2ae5216213044e292
 #: ../../interaction_based_testing.rst:186
 msgid ""
 "When expecting a call to a setter method, only method syntax can be used::"
 msgstr ""
-"逆にセッターメソッドの呼び出しを期待する場合は、メソッドの構文のみが使用できます。"
+"セッターの場合は、通常のメソッドと同じように指定する必要があります。"

 # 922b9cdcc93842ebb533f0e576994bab
 #: ../../interaction_based_testing.rst:191
@@ -402,7 +403,7 @@ msgstr ""
 msgid ""
 "Argument constraints work as expected for methods with multiple arguments::"
 msgstr ""
-"引数制約は複数の引数を持つメソッドに対しても問題なく動作します。"
+"複数の引数を持つメソッドに対しても問題なく使用できます。"

 # 607bcfd285c0441ebef7bc92e267ae89
 #: ../../interaction_based_testing.rst:209
@@ -410,7 +411,7 @@ msgid ""
 "When dealing with vararg methods, vararg syntax can also be used in the "
 "corresponding interactions::"
 msgstr ""
-"可変長引数のメソッドを扱う場合も、同じように相互作用を宣言できます。"
+"また可変長引数のメソッドに対しても、同じようにインタラクションを定義できます。"

 # acc5f693a51b4b3ca00bf183a8707c08
 #: ../../interaction_based_testing.rst:221
@@ -419,8 +420,8 @@ msgid ""
 "in vararg style. Consequently, vararg syntax can also be used in "
 "interactions matching such methods."
 msgstr ""
-"Groovyのメソッドは最後のパラメータを配列とすると可変長引数が使用できます。"
-"可変長引数の構文と同様に、このようなメソッドに対しても相互作用のマッチングが行えます。"
+"Groovyではメソッドの最後のパラメータを、配列として宣言すると可変長引数として扱います。"
+"可変長引数のメソッドと同じように、このようなメソッドに対してもインタラクションのマッチングが行えます。"

 # 14cd2169aba94449b8480464e4f10e0f
 #: ../../interaction_based_testing.rst:225
@@ -432,7 +433,7 @@ msgstr "すべてのメソッド呼び出しに対するマッチング"
 msgid ""
 "Sometimes it can be useful to match \"anything\", in some sense of the word::"
 msgstr ""
-"いくつかの単語の意味を含む、\"何か\"に一致できると便利な場合があります。"
+"\"何にでも\"一致するという指定が便利な場合もあります。"

 # 1bcbbe46c8ec4e52bbab7cf46855b643
 #: ../../interaction_based_testing.rst:235
@@ -440,13 +441,13 @@ msgid ""
 "Although ``(_.._) * _._(*_) >> _`` is a valid interaction declaration, it is "
 "neither good style nor particularly useful."
 msgstr ""
-"\\ ``(_.._) * _._(*_) >> _``\\ は有効な相互作用の定義ですが、"
+"\\ ``(_.._) * _._(*_) >> _``\\ は有効なインタラクションの定義ですが、"
 "これは良いスタイルでもなければ、便利な場面があるわけでもありません。"

 # 59e83546c22047bc8f90c18f87fcfa20
 #: ../../interaction_based_testing.rst:239
 msgid "Strict Mocking"
-msgstr "Strictなモック"
+msgstr "Strictモッキング"

 # 192f5fb0081d4765a3b4b32e12b68201
 #: ../../interaction_based_testing.rst:241
@@ -455,9 +456,9 @@ msgid ""
 "*strict mocking*, a style of mocking where no interactions other than those "
 "explicitly declared are allowed::"
 msgstr ""
-"先ほどの、すべてのメソッド呼び出しに対するマッチングはどのような時に役立つでしょうか？"
-"よい例が\\ *strictなモック*\\ です。"
-"このモックのスタイルは明示的に宣言した相互作用以外を許可しません。"
+"上記のすべてのメソッド呼び出しに対するマッチングはどのような時に役立つでしょうか？"
+"よい例が\\ *strictモッキング*\\ です。"
+"このモックのスタイルは明示的に定義したインタラクション以外を許容しません。"

 # 90528da444804393a3710cc342f89b3c
 #: ../../interaction_based_testing.rst:252
@@ -466,10 +467,10 @@ msgid ""
 "method. Note the use of ``_ *`` (any number of calls), which allows any "
 "interaction with the auditing component."
 msgstr ""
-"``0 *``\\ は\\ ``then:``\\ ブロックまたはメソッドの最後の相互作用"
-"として入れることで意味をなします。"
-"\\ ``_ *``\\  (任意の呼び出し回数)は、auditingコンポーネントに対して"
-"任意の呼び出し回数を許可しています。"
+"このように\\ ``0 *``\\ を\\ ``then:``\\ ブロック、またはメソッドの最後のインタラクション"
+"として定義することで効果を発揮します。"
+"また\\ ``_ *``\\ (任意の呼び出し回数)は、auditingコンポーネントに対して"
+"任意の呼び出し回数を許容することを表しています。"

 # 2c90f36ada0643ffb41c8df0d7d21e5c
 #: ../../interaction_based_testing.rst:255
@@ -479,15 +480,15 @@ msgid ""
 "example, ``_ * auditing.record(_) >> \"ok\"`` can (and should!) be "
 "simplified to ``auditing.record(_) >> \"ok\"``."
 msgstr ""
-"``_ *``\\ はstrictなモックを行う場合にのみ有効です。"
-"特に\\ :ref:`スタブする <Stubbing>`\\ 場合は必要になることはありません。"
+"``_ *``\\ はstrictモッキングを行う場合にのみ有効です。"
+"特に\\ :ref:`スタビング <Stubbing>`\\ を行う場合は必要になることはありません。"
 "例えば\\ ``_ * auditing.record(_) >> \"ok\"``\\ は単に\\ ``auditing.record(_) >> \"ok\"``\\ "
-"と宣言することができます(すべき！)。"
+"と定義すべきです。"

 # d4d4f1d3c3374d30b7f64f75219c2dd3
 #: ../../interaction_based_testing.rst:262
 msgid "Where to Declare Interactions"
-msgstr "相互作用の宣言場所"
+msgstr "インタラクションの宣言場所"

 # c8a950dba7aa4d1895fb8316438b25e7
 #: ../../interaction_based_testing.rst:264
@@ -499,12 +500,12 @@ msgid ""
 "a ``setup`` method. Interactions can also be declared in any \"helper\" "
 "instance method of the same specification class."
 msgstr ""
-"ここまで見てきた例では相互作用は\\ ``then:``\\ に宣言してきました。 "
-"これは自然にスペックが読めるという効果があります。"
-"しかし、実際には\\ ``when:``\\ ブロックの\\ *前*\\ で相互作用を"
-"宣言することもできます。これは\\ ``setup``\\ メソッド内でも宣言できることを"
-"意味しています。同じようにスペッククラス内で別のヘルパークラスで"
-"相互作用を宣言するといったことも可能です。"
+"ここまで見てきた例ではインタラクションを、\\ ``then:``\\ ブロックに定義してきました。 "
+"これはより自然にスペックが読めるという効果がありますが、"
+"インタラクションを\\ ``when:``\\ ブロックの\\ *前*\\ で"
+"定義することもできます。これは\\ ``setup``\\ といったメソッドでも定義できることを"
+"意味しています。同じように他のヘルパークラスで"
+"インタラクションを定義し、スペッククラス内から呼び出すといったことも可能です。"

 # b3d04638403d4663a9491afa4f22893f
 #: ../../interaction_based_testing.rst:269
@@ -517,13 +518,13 @@ msgid ""
 "other interactions. This allows to override interactions declared in, say, a "
 "``setup`` method with interactions declared in a ``then:`` block."
 msgstr ""
-"モックオブジェクトへの呼び出しが発生すると、相互作用は宣言された"
-"順番に評価されます。もし、呼び出しが複数の相互作用にマッチする場合は"
-"マッチの上限に達してない限り、先に宣言した相互作用が優先して"
-"評価されます。ただし例外があり\\ ``then:``\\ ブロックで宣言した相互作用は"
-"他の相互作用よりも先に評価されます。これは\\ ``setup``\\ など"
-"他のブロックで宣言した相互作用よりも\\ ``then:``\\ ブロックで"
-"宣言した相互作用が先にマッチングされるということを意味しています。"
+"モックオブジェクトへの呼び出しが発生すると、インタラクションは定義した"
+"順番に評価されます。もし、呼び出しが複数のインタラクションにマッチする場合は"
+"マッチの上限に達してない限り、先に定義したインタラクションが優先して"
+"評価されます。ただし例外があり\\ ``then:``\\ ブロックで定義したインタラクションは"
+"他のインタラクションよりも先に評価されます。これは\\ ``setup``\\ など"
+"他のメソッドやブロックで定義したインタラクションよりも\\ ``then:``\\ ブロックで"
+"定義したインタラクションが先に評価されることを意味しています。"

 # 9840aea6a6ce4022a010da2193e74d2d
 #: ../../interaction_based_testing.rst:277
@@ -539,20 +540,20 @@ msgid ""
 "stubbing). Either of them must always be present; ``foo.bar()`` alone will "
 "never be considered an interaction."
 msgstr ""
-"どのように通常のメソッドではなく相互作用の宣言だとSpockは"
-"認識しているのでしょうか？Spockでは相互作用の宣言を認識するために"
+"(質問: どのように通常のメソッドではなくインタラクションの定義だと"
+"識別しているのか？) Spockではインタラクションの定義を識別するために、"
 "簡単なルールを持っています。これは、式があった場合に、乗算(``*``)、または"
-"左シフト(``>>``, ``>>>``)のどちらか含まれていると、それを相互作用"
-"の宣言として認識します。このような式は、本来もっている式の意味を変えることで"
-"動作してます。実行回数の宣言(モックする時)と、レスポンス生成(スタブする時)"
-"の構文を間違えないようにしてください。これらは必ずどちらかが"
-"指定されなければなりません。\\ ``foo.bar()``\\ といった単独の式が相互作用"
-"として認識されることはありません。"
+"左シフト(``>>``, ``>>>``)のどちらか含まれていた場合に、インタラクション"
+"の定義として識別します。このような式は、本来もっている式の意味を変えることで、"
+"正しく動作してます。また、多重度の定義(モッキング)と、レスポンス定義(スタビング)"
+"の構文を間違わないようにしてください。これらは必ずどちらかが、"
+"定義されなければなりません。\\ ``foo.bar()``\\ といった単独の式が、インタラクション"
+"として識別されることはありません。"

 # 08b0975f40aa457688984f769623f0c5
 #: ../../interaction_based_testing.rst:288
 msgid "Declaring Interactions at Mock Creation Time (New in 0.7)"
-msgstr "モック作成時の相互作用宣言 (New in 0.7)"
+msgstr "モック作成時のインタラクション定義 (New in 0.7)"

 # ec27a82373794705b5ffc83d308d0b29
 #: ../../interaction_based_testing.rst:290
@@ -560,8 +561,8 @@ msgid ""
 "If a mock has a set of \"base\" interactions that don't vary, they can be "
 "declared right at mock creation time::"
 msgstr ""
-"もしモックが動的に変化しない\\ \"ベース\"\\ となる相互作用を持っている"
-"場合は、モック作成時に相互作用を宣言できます。"
+"もしモックが動的に変化しない\\ \"基本\"\\ となるインタラクションがある"
+"場合は、モック作成時にインタラクションを定義できます。"

 # 5afcecf8d1cf499595f8ca06bad1e56b
 #: ../../interaction_based_testing.rst:297
@@ -571,10 +572,10 @@ msgid ""
 "[#targetContext]_) have a target constraint; it's clear from the context "
 "which mock object they belong to."
 msgstr ""
-"この機能は\\ :ref:`スタブする <Stubbing>`\\ ことにより専用の\\ :ref:`スタブ <Stubs>`\\ を作る際に"
+"この機能は\\ :ref:`スタビング <Stubbing>`\\ により専用の\\ :ref:`スタブ <Stubs>`\\ を作る際にも"
 "便利な機能です。"
-"相互作用は対象制約が含まれていない(持てない\\ [#targetContext]_\\ )ことに注意してください。"
-"これは作成するモックのコンテキストで動作することが明らかだからです。"
+"ここで、インタラクションに対象制約を含んでいない(参照できない\\ [#targetContext]_\\ )ことに注意してください。"
+"これは作成するモックのコンテキストで動作することが明白なためです。"

 # 596cb22985674a0586ad32d60a3d92ac
 #: ../../interaction_based_testing.rst:301
@@ -582,12 +583,12 @@ msgid ""
 "Interactions can also be declared when initializing an instance field with a "
 "mock::"
 msgstr ""
-"また相互作用はフィールドをモックで初期化する場合にも使用できます。"
+"また、フィールドをモックで初期化する場合にも使用できます。"

 # 5bd33a5bc850471c9ecff02914849e40
 #: ../../interaction_based_testing.rst:313
 msgid "Grouping Interactions with Same Target (New in 0.7)"
-msgstr "相互作用のグループ化 (New in 0.7)"
+msgstr "インタラクションのグループ化 (New in 0.7)"

 # b5f406a14c4e430bbaa32092a34dbd8f
 #: ../../interaction_based_testing.rst:315
@@ -597,11 +598,11 @@ msgid ""
 "<DeclaringInteractionsAtMockCreationTime>`, this makes it unnecessary to "
 "repeat the target constraint::"
 msgstr ""
-"``Specification.with``\\ ブロックで対象を共有することで"
-"相互作用のグループ化が行えます。"
-"これは\\ :ref:`モック作成時の相互作用宣言\\ "
+"``Specification.with``\\ ブロックで対象制約を共有することで、"
+"インタラクションのグループ化が行えます。"
+"これは\\ :ref:`モック作成時のインタラクション宣言\\ "
 "<DeclaringInteractionsAtMockCreationTime>`\\ と同じように、"
-"対象制約を繰り返す必要がなくなります。"
+"対象制約を繰り返し指定する必要がなくなります。"

 # 0873c63f191e41e096ef18a7f3f03689
 #: ../../interaction_based_testing.rst:324
@@ -609,12 +610,12 @@ msgid ""
 "A ``with`` block can also be used for grouping conditions with the same "
 "target."
 msgstr ""
-"``with``\\ ブロックは特定の対象に対する条件のグループ化にも使用できます。"
+"また、\\ ``with``\\ ブロックは特定の対象に対する、コンディションのグループ化にも使用できます。"

 # ad0064f04dc64f1dbbf1f99139e98180
 #: ../../interaction_based_testing.rst:327
 msgid "Mixing Interactions and Conditions"
-msgstr "相互作用と条件の組み合わせ"
+msgstr "インタラクションとコンディションの組み合わせ"

 # 9772b3b772fd4c669ae8fb8e7aca8d7a
 #: ../../interaction_based_testing.rst:329
@@ -623,8 +624,8 @@ msgid ""
 "strictly required, it is customary to declare interactions before "
 "conditions::"
 msgstr ""
-"``then:``\\ ブロックには相互作用と条件の両方を同時に含むことが"
-"できます。厳密には必須ではありませんが、条件の前に相互作用を宣言するのが一般的です。"
+"``then:``\\ ブロックにはインタラクションと、コンディションの両方を同時に含むことが"
+"できます。厳密には必須ではありませんが、コンディションの前にインタラクションを定義するのが一般的です。"

 # 11245c092de149da8e987b67a8f3462d
 #: ../../interaction_based_testing.rst:339
@@ -640,7 +641,7 @@ msgstr ""
 # c349252f6bf84850a9ca2c8056d0ce3c
 #: ../../interaction_based_testing.rst:343
 msgid "Explicit Interaction Blocks"
-msgstr "明示的な相互作用ブロック"
+msgstr "明示的なインタラクションブロック"

 # 392e3daa569448cc8831adf3519e873f
 #: ../../interaction_based_testing.rst:345
@@ -652,10 +653,10 @@ msgid ""
 "preceding ``when:`` block. In most cases this works out just fine, but "
 "sometimes it can lead to problems::"
 msgstr ""
-"仕組み上、Spockは実行\\ *前*\\ に全ての相互作用を保持しておく必要があります。"
-"それではなぜ\\ ``then:``\\ ブロックで相互作用が"
-"宣言可能なのでしょうか？内部的には、\\ ``then:``\\ ブロック"
-"で宣言した相互作用は\\ ``when:``\\ ブロックの直前に移動されます。"
+"仕組み上、Spockは実行\\ *前*\\ に定義された、インタラクション全ての情報を保持する必要があります。"
+"では、なぜ\\ ``then:``\\ ブロックでインタラクションが"
+"定義可能なのでしょうか？内部的には、\\ ``then:``\\ ブロック"
+"で定義したインタラクションは、実行前に\\ ``when:``\\ ブロックの前に移動されます。"
 "これは大抵の場合に問題なく動作しますが、特定の条件下では問題を引き起こす場合があります。"

 # 806f4afad39f458fa89965f0599c9a68
@@ -667,10 +668,10 @@ msgid ""
 "the variable declaration. Hence it will just move the interaction, which "
 "will cause a ``MissingPropertyException`` at runtime."
 msgstr ""
-"この例では期待する引数を変数に受けています(実行回数を変数に受ける場合も"
-"場合も同様)。しかしながらSpockは相互作用からこの後で宣言される変数"
-"を参照できるほど賢くはありません(だってそうでしょう？)。"
-"そのために単純に相互作用を移動しただけでは、実行時に"
+"この例では期待する引数を変数に受けています(多重度を変数に受ける場合も"
+"場合も同様)。ここでインタラクションを移動すると、インタラクションからこの後で宣言する変数"
+"を参照していることになり、もちろんこのような参照は許容されません。"
+"このように単純にインタラクションを移動しただけでは、実行時に"
 "\\ ``MissingPropertyException``\\ を引き起こします。"

 # fea4deb35c7041619cee28bfaa6cf8e5
@@ -683,9 +684,9 @@ msgid ""
 "variable for sending the message."
 msgstr ""
 "この問題を解決する一つの方法は変数宣言を(少なくとも)\\ ``when:``\\ ブロックの前"
-"に移動することです(\\ :ref:`データ駆動テスト <DataDrivenTesting>`\\ の愛好者は"
-"\\ ``where:``\\ ブロックに変数を移動するかもしれません)。上の例では"
-"送信するメッセージと同じ変数を使用できるというメリットもあります。"
+"に移動することです(\\ :ref:`データ駆動テスト <DataDrivenTesting>`\\ が好きなユーザは"
+"\\ ``where:``\\ ブロックに変数を移動するかもしれません)。上の例では、副作用として"
+"送信するメッセージと同じ変数を共有できるというメリットもあります。"

 # cfab1b38d4fd4f97bcf26017fc4e5985
 #: ../../interaction_based_testing.rst:366
@@ -693,7 +694,7 @@ msgid ""
 "Another solution is to be explicit about the fact that variable declaration "
 "and interaction belong together::"
 msgstr ""
-"もう一つの解決方法は変数を相互作用と共に使用するということを"
+"もう一つの解決方法は、変数をインタラクションと共に使用することを"
 "明示することです。"

 # d3edff9f195846f5b891ab3172bd633f
@@ -702,13 +703,13 @@ msgid ""
 "Since an ``MockingApi.interaction`` block is always moved in its entirety, "
 "the code now works as intended."
 msgstr ""
-"``MockingApi.interaction``\\ ブロックは常にそのブロック全体が移動するため、"
-"このコードは意図通りに動作します。"
+"``MockingApi.interaction``\\ ブロックは、常にそのブロック全体が移動するため、"
+"このコードは意図した通りに動作します。"

 # 25be090c816b481c9bd635321510790b
 #: ../../interaction_based_testing.rst:380
 msgid "Scope of Interactions"
-msgstr "相互作用のスコープ"
+msgstr "インタラクションのスコープ"

 # 461a388537e44c2b906272225e4a3332
 #: ../../interaction_based_testing.rst:382
@@ -716,8 +717,8 @@ msgid ""
 "Interactions declared in a ``then:`` block are scoped to the preceding "
 "``when:`` block::"
 msgstr ""
-"``then:``\\ ブロックで宣言した相互作用は、直前の\\ ``when:``\\ "
-"に対してスコープを持ちます。"
+"``then:``\\ ブロックで定義したインタラクションは、直前の\\ ``when:``\\ "
+"ブロックのみがスコープの対象となります。"

 # f40bfad2d9b641a381907a35e3292ade
 #: ../../interaction_based_testing.rst:396
@@ -726,9 +727,9 @@ msgid ""
 "execution of the first ``when:`` block, and ``\"message2\"`` during "
 "execution of the second ``when:`` block."
 msgstr ""
-"これは\\ ``subscriber``\\ がはじめの\\ ``when:``\\ ブロックで\\ ``\"message1\"``\\ "
-"を受信した確認でき、次の\\ ``when:``\\ で\\ ``\"message2\"``\\ を受信した確認を"
-"行えること意味しています。"
+"これは最初の\\ ``when:``\\ ブロックで\\ ``subscriber``\\ が\\ ``\"message1\"``\\ "
+"を受信した確認を行い、次の\\ ``when:``\\ で\\ ``\"message2\"``\\ を受信した確認を"
+"行なっています。"

 # 9d56f46a1c244f0e80cbb8d36e9adf92
 #: ../../interaction_based_testing.rst:399
@@ -736,7 +737,7 @@ msgid ""
 "Interactions declared outside a ``then:`` block are active from their "
 "declaration until the end of the containing feature method."
 msgstr ""
-"``then:``\\ ブロックの外で宣言した相互作用は、そのフィーチャーメソッド"
+"``then:``\\ ブロックの外で宣言したインタラクションは、そのフィーチャーメソッド"
 "が完了するまで有効になります。"

 # bb4888b632b14848946afcddbbf88b82
@@ -747,16 +748,16 @@ msgid ""
 "``cleanupSpec`` method. Likewise, mock objects should not be stored in "
 "static or ``@Shared`` fields."
 msgstr ""
-"相互作用は常に特定のフィーチャーメソッドに対してスコープを"
-"持ちます。そのため、相互作用をstaticメソッド、\\ ``setupSpec``\\  メソッド、"
-"また\\ ``cleanupSpec``\\ メソッドで宣言することはできません。"
-"同様にモックオブジェクトはstatic、または\\ ``@Shared``\\ フィールドにすべきでは"
-"ありません。"
+"また、インタラクションは常に特定のフィーチャーメソッドに対してスコープを"
+"持ちます。そのため、インタラクションをstaticメソッド、\\ ``setupSpec``\\  メソッド、"
+"また\\ ``cleanupSpec``\\ メソッドで定義することはできません。"
+"このような理由により、static、または\\ ``@Shared``\\ フィールドにも"
+"モックオブジェクトを設定すべきではありません。"

 # 08444aea9ae145ffbc249d12094622be
 #: ../../interaction_based_testing.rst:407
 msgid "Verification of Interactions"
-msgstr "相互作用の検証"
+msgstr "インタラクションの検証"

 # c0bc449e82484a33b9f2110f6b1b4e33
 #: ../../interaction_based_testing.rst:409
@@ -766,11 +767,11 @@ msgid ""
 "than required. The former case is detected right when the invocation "
 "happens, and causes a ``TooManyInvocationsError``::"
 msgstr ""
-"モックベースのテストが失敗する理由は主に2つです。期待した相互作用"
-"以上に呼び出しがマッチするか、もしくは期待した相互作用の"
-"呼び出しに満たいない場合です。"
-"前者の場合は、実際に発生した呼び出し回数を表示し\\ ``TooManyInvocationsError``\\ "
-"が発生します。"
+"モックベースのテストが失敗する理由は主に2つです。期待したインタラクション"
+"以上に呼び出しが発生するか、もしくは期待したインタラクションに"
+"呼び出しが満たいない場合です。"
+"前者の場合は、\\ ``TooManyInvocationsError``\\ が発生し、"
+"実際に発生した呼び出し回数が表示されます。"

 # e00f4e234867490b83796ef19b8004aa
 #: ../../interaction_based_testing.rst:419
@@ -779,8 +780,9 @@ msgid ""
 "show all invocations matching the interaction in question (new in Spock "
 "0.7)::"
 msgstr ""
-"多くの相互作用がマッチする場合に簡単に解析が行えるように、"
-"呼び出しに関連する全ての相互作用を表示します(new in Spock "
+"このようなエラーが発生した場合は、"
+"期待した以上に呼び出しが発生した原因の解析が容易に行えるよう、"
+"呼び出しに関連する全てのインタラクションを表示します(new in Spock "
 "0.7)。"

 # 7c9ee5fb12564f83bd5fc73a83cbee46
@@ -793,10 +795,10 @@ msgid ""
 "occurred before the ``receive(\"goodbye\")``."
 msgstr ""
 "この出力によると\\ ``receive(\"hello\")``\\ が原因となり\\ ``TooManyInvocationsError``\\ "
-"発生しています。ここでは\\ ``subscriber.receive(\"hello\")``\\ の2度の呼び出しに"
-"エラーがあったということに情報が集約されてしまうことに注意してください。"
-"``receive(\"hello\")``\\ で先にエラーとなったためで\\ ``receive(\"goodbye\")``\\ "
-"にもエラーがあった場合との区別が付きません。"
+"発生しています。ここでは\\ ``subscriber.receive(\"hello\")``\\ の呼び出しで"
+"エラーがあったということに、情報が集約されてしまうことに注意してください。"
+"``receive(\"hello\")``\\ で先にエラーとなると\\ ``receive(\"goodbye\")``\\ "
+"にもエラーがあった場合と区別が付きません。"

 # b71364945e7b485588aacef64bae4cd1
 #: ../../interaction_based_testing.rst:431
@@ -805,9 +807,9 @@ msgid ""
 "execution of the ``when`` block has completed. (Until then, further "
 "invocations may still occur.) It causes a ``TooFewInvocationsError``::"
 msgstr ""
-"2つめの場合(必要としたよりも少ない呼び出し)は\\ ``when``\\ ブロックの実行が"
-"完了した時点で検出できます(それが終了するまでは呼び出しの可能性があるため)。"
-"これは\\ ``TooFewInvocationsError``\\ が発生します。"
+"2つめの場合(期待したインタラクションに呼び出しが満たいない場合)は、\\ ``when``\\ ブロックの実行が"
+"完了した時点でエラーを検出します(終了するまでは呼び出しの可能性があるため)。"
+"エラーの場合は\\ ``TooFewInvocationsError``\\ が発生します。"

 # a975655d13a54dcfb6b77527448c6050
 #: ../../interaction_based_testing.rst:438
@@ -818,9 +820,9 @@ msgid ""
 "this one; in either case, a ``TooFewInvocationsError`` error will occur."
 msgstr ""
 "これはメソッドの呼び出しが全くなかったということではありません。"
-"同じメソッドが、他の引数で呼び出された、異なるモックオブジェクトで呼び出された、"
-"\"別の\"メソッドが呼び出されたなど。いずれの場合でも"
-"\\ ``TooFewInvocationsError``\\ のエラーが発生します。"
+"同じメソッドが、他の引数で呼び出された、異なるモックオブジェクトで呼び出された、もしくは"
+"\"別の\"メソッドが呼び出されたといったことが考えられます。"
+"これらいずれの場合でも、\\ ``TooFewInvocationsError``\\ のエラーが発生します。"

 # a5c3cbfc0f564150b51e22dca4ba8e71
 #: ../../interaction_based_testing.rst:444
@@ -831,10 +833,10 @@ msgid ""
 "(new in Spock 0.7). In particular, invocations that match everything but the "
 "interaction's arguments will be shown first::"
 msgstr ""
-"なぜ必要とした呼び出しが行われなかったのかを簡単に解析できるように、"
-"必要とした相互作用に類似している順に、相互作用と一致しなかった"
-"全ての呼び出しを出力します(new in Spock 0.7)。"
-"具体的には相互作用の引数に一致する呼び出しが最初に表示されます。"
+"なぜ期待した呼び出しが行われなかったかを簡単に解析できるように、"
+"インタラクションに一致しない呼び出しがあった場合は、"
+"呼び出しに類似している順に、全てのインタラクションを表示します(new in Spock 0.7)。"
+"具体的には引数が一致するインタラクションを最初に表示します。"

 # 45d741277a17466ba6334bd9d7117582
 #: ../../interaction_based_testing.rst:454
@@ -848,9 +850,9 @@ msgid ""
 "time. To avoid over-specification, Spock defaults to allowing any invocation "
 "order, provided that the specified interactions are eventually satisfied::"
 msgstr ""
-"大抵の場合、メソッドの呼び出し順序は重要ではなく、また実行順序は時間と共に変更される"
-"可能性があるものでもあります。over-specificationを避けるために、Spockではデフォルトで"
-"最終的に指定した相互作用を満たしていれば、"
+"大抵の場合にメソッドの呼び出し順序は重要ではありません。また実行順序は時間と共に変更される"
+"可能性が高いものでもあります。Spockはデフォルトでは、over-specificationを避けるため、"
+"最終的に定義したインタラクションすべてが満たされていれば、"
 "どのような実行順序でも許容します。"

 # f2530818dd4d47ceab5ddefbd574f563
@@ -862,7 +864,7 @@ msgid ""
 msgstr ""
 "ここで呼び出し順序は ``\"hello\"`` ``\"hello\"`` ``\"goodbye"
 "\"``、``\"hello\"`` ``\"goodbye\"`` ``\"hello\"``、または ``\"goodbye\"`` ``"
-"\"hello\"`` ``\"hello\"`` のいずれの場合も指定した相互作用を満たしています。"
+"\"hello\"`` ``\"hello\"`` のいずれの場合も定義したインタラクションを満たしています。"

 # 2374f3bb6a0743f4a17590dae87df65b
 #: ../../interaction_based_testing.rst:466
@@ -870,8 +872,8 @@ msgid ""
 "In those cases where invocation order matters, you can impose an order by "
 "splitting up interactions into multiple ``then:`` blocks::"
 msgstr ""
-"実行順序が重要な意味をもつ場合は、相互作用を複数の\\ ``then:``\\ "
-"ブロックに分割することで順序の確認が行えます。"
+"実行順序が重要な意味をもつ場合は、インタラクションを複数の\\ ``then:``\\ "
+"ブロックに分割することで、順序の検証が行えます。"

 # 0847a86faa6a477ba933c58efc5fef87
 #: ../../interaction_based_testing.rst:475
@@ -880,11 +882,10 @@ msgid ""
 "\"goodbye\"``. In other words, invocation order is enforced *between* but "
 "not *within* ``then:`` blocks."
 msgstr ""
-"これは\\ ``\"goodby\"``\\ を受信するまえに、\\ ``\"hello\"``\\ を2回"
-"受信することを検証します。このように\\ ``then:``\\ ブロック\\ **内**\\ では"
-"順序の検証しませんが、\\ ``then:``\\ ブロックを複数に分割することで、"
-"ブロック毎に相互作用を満たしているかの検証を行うため、"
-"ブロック\\ **間**\\ での順序の検証が行えます。"
+"これは\\ ``\"goodby\"``\\ を受信する前に、\\ ``\"hello\"``\\ を2回"
+"受信することを検証しています。このように\\ ``then:``\\ ブロック\\ **内**\\ では"
+"実行順序の検証を行いませんが、\\ ``then:``\\ ブロックを複数に分割することで、"
+"ブロック\\ **間**\\ の実行順序の検証が行えます。"

 # 147969b5b4aa478f87f661478a3d9b1b
 #: ../../interaction_based_testing.rst:478
@@ -893,14 +894,14 @@ msgid ""
 "as ``and:`` is only meant for documentation purposes and doesn't carry any "
 "semantics."
 msgstr ""
-"\\ ``then:``\\ ブロックを\\ ``and:``\\ を使用して分割した場合は順序の検証を"
+"\\ ``then:``\\ ブロックを\\ ``and:``\\ を使用して分割した場合は、順序の検証を"
 "行なっていることにはなりません。\\ ``and:``\\ は単なるドキュメンテーション"
 "目的のために存在しており、実行時の動作には何も影響を与えません。"

 # 2dc1ec483ab14dbbbdff3be437004502
 #: ../../interaction_based_testing.rst:482
 msgid "Mocking Classes"
-msgstr "クラスのモック"
+msgstr "クラスのモッキング"

 # ba3de6a30bd746ca9d9f79964c0dd9f9
 #: ../../interaction_based_testing.rst:484
@@ -911,16 +912,16 @@ msgid ""
 "class path. If either of these libraries is missing from the class path, "
 "Spock will gently let you know."
 msgstr ""
-"Spockではインタフェースの他にクラスのモックもサポートしています。"
-"クラスをモックするは場合もインターフェースと同じように機能します。ただし"
-"クラスをモックする場合は\\ ``cglib-nodep-2.2``\\ 以上、\\ ``objenesis-1.2``\\ 以上が"
-"クラスパスに含まれている必要があります。もしこれらのライブラリが"
+"Spockではインタフェースの他に、クラスのモッキングもサポートしています。"
+"クラスのモッキングも、インターフェースと同じように使用できます。ただし"
+"クラスをモッキングする場合は\\ ``cglib-nodep-2.2``\\ 以上、\\ ``objenesis-1.2``\\ 以上が、"
+"クラスパスに含まれている必要があります。もしこれらのライブラリが、"
 "クラスパスに含まれていない場合はSpockが警告を出力します。"

 # d07bd4f127f24d909709390ed6b4c0cd
 #: ../../interaction_based_testing.rst:492
 msgid "Stubbing"
-msgstr "スタブする"
+msgstr "スタビング(Stubbing)"

 # 4426e06b49ee4254a4b989b07f715bc2
 #: ../../interaction_based_testing.rst:494
@@ -930,8 +931,8 @@ msgid ""
 "the method is going to be called; you just want it to return some value, or "
 "perform some side effect, *whenever* it gets called."
 msgstr ""
-"スタブするとは特定のメソッド呼び出しに対して応答を振る舞うことです。"
-"メソッドをスタブする場合は、そのメソッドが何度呼ばれるかを気にせずに"
+"スタビングとは特定のメソッド呼び出しに対する、応答を定義することです。"
+"メソッドをスタビングする場合は、そのメソッドが何回呼ばれるかを気にせず、"
 "\\ *いつ呼び出されても*\\ 特定の値を返したり、何かの副作用が働くように"
 "します。"

@@ -943,7 +944,7 @@ msgid ""
 "able to process a message::"
 msgstr ""
 "例を示すために、\\ ``Subscriber``\\ の\\ ``receive``\\ メソッドの処理が"
-"完了した場合にステータスコードを返すように変更してみましょう。"
+"完了した場合に、ステータスコードを返すように変更してみましょう。"

 # 56f4aa2005d94e1699564e7336344c5f
 #: ../../interaction_based_testing.rst:505
@@ -951,8 +952,8 @@ msgid ""
 "Now, let's make the ``receive`` method return ``\"ok\"`` on every "
 "invocation::"
 msgstr ""
-"それでは\\ ``receive``\\ メソッドが常に\\ ``\"ok\"``\\ "
-"を返却するようにします。"
+"ここで\\ ``receive``\\ メソッドが常に\\ ``\"ok\"``\\ "
+"を返すようにします。"

 # 609c0e066b034d928bfe3353bba1d36d
 #: ../../interaction_based_testing.rst:509
@@ -960,7 +961,7 @@ msgid ""
 "Read out aloud: \"*Whenever* the subscriber receives a message, *make* it "
 "respond with 'ok'.\""
 msgstr ""
-"言葉にしてみると「subscriber が メッセージ を 受信 するたびに 'ok' で 応答する」"
+"文章としてコードを読んでみると「subscriber が メッセージ を 受信 するたびに 'ok' で 応答する」"
 "になります。"

 # 8a7856c68b8e490582ace72bec8d0d92
@@ -969,8 +970,8 @@ msgid ""
 "Compared to a mocked interaction, a stubbed interaction has no cardinality "
 "on the left end, but adds a *response generator* on the right end::"
 msgstr ""
-"モック時の相互作用と比べると、スタブの相互作用は左に"
-"実行回数がない代わりに、右に\\ *応答の仕方*\\ が加えられています。"
+"モック時のインタラクションと比べると、スタブのインタラクションは左に"
+"多重度がない代わりに、右に\\ *レスポンスジェネレータ*\\ を指定します。"

 # c28b3a6a6934485f93b4dcae3f4e7128
 #: ../../interaction_based_testing.rst:521
@@ -981,12 +982,12 @@ msgid ""
 "for stubbing, it's common to declare interactions :ref:`at mock creation "
 "time <DeclaringInteractionsAtMockCreationTime>` or in a ``setup:`` block."
 msgstr ""
-"スタブの相互作用は、\\ ``then:``\\ ブロック内や\\ ``when:``\\ ブロック"
+"スタブのインタラクションは、\\ ``then:``\\ ブロック内や\\ ``when:``\\ ブロック"
 "の前など、どのような場所でも宣言することができます"
 "\\ (詳細は\\ :ref:`WhereToDeclareInteractions`\\ を参照)。"
-"もしモックオブジェクトをスタブとしてのみ使用する場合は"
-"\\ :ref:`モックの作成時 <DeclaringInteractionsAtMockCreationTime>`\\ "
-"や\\ ``setup:``\\ ブロック内で相互作用を宣言するのが一般的です。"
+"もし、モックオブジェクトをスタブとしてのみ使用する場合は、"
+"\\ :ref:`モック作成時 <DeclaringInteractionsAtMockCreationTime>`\\ "
+"や\\ ``setup:``\\ ブロック内でインタラクションを定義するのが一般的です。"

 # 8d45e48c3219471bb25d3e9b0c0c4397
 #: ../../interaction_based_testing.rst:527
@@ -1007,7 +1008,7 @@ msgid ""
 "To return different values for different invocations, use multiple "
 "interactions::"
 msgstr ""
-"異なる実行に対して別の値を返すには、それぞれ複数の相互作用を"
+"異なる実行に対して別の値を返すには、それぞれ複数のインタラクションを"
 "宣言します。"

 # d4f8bf87df614b639406ac0e8625e202
@@ -1134,7 +1135,7 @@ msgid ""
 "the interaction."
 msgstr ""
 "もちろんクロージャの中には\\ ``println``\\ といった、より多くのコードを"
-"含むことができます。この例ではメソッドの引数が相互作用と"
+"含むことができます。この例ではメソッドの引数がインタラクションと"
 "一致するたびに例外がスローされます。"

 # 04e96047ccb94d8daa1cbdd7747d71c8
@@ -1175,8 +1176,8 @@ msgid ""
 "same interaction. In particular, the following Mockito-style splitting of "
 "stubbing and mocking into two separate statements will *not* work::"
 msgstr ""
-"モックとスタブを同じメソッドに対して使用する場合は、同じ相互作用として"
-"宣言する必要があります。これはMockitoのようにモックする処理とスタブする処理を"
+"モックとスタブを同じメソッドに対して使用する場合は、同じインタラクションとして"
+"宣言する必要があります。これはMockitoのようにモッキング処理とスタビング処理を"
 "別々に宣言することが\\ *できません*\\ 。"

 # b6f2c8d0b2f44fdbab3d1c66425b67c2
@@ -1190,11 +1191,11 @@ msgid ""
 "the ``setup:`` block will never get a chance to match."
 msgstr ""
 ":ref:`WhereToDeclareInteractions`\\ で説明したように\\ ``receive``\\ が呼ばれると、"
-"まずはじめに\\ ``then:``\\ ブロックで宣言した相互作用が評価されます。"
-"この相互作用は特定のレスポンスが指定されていないため、メソッドの"
+"まずはじめに\\ ``then:``\\ ブロックで宣言したインタラクションが評価されます。"
+"このインタラクションは特定のレスポンスが指定されていないため、メソッドの"
 "デフォルトの値(この場合は\\ `null`\\ )を返します(これはSpockがlenient(緩い)なモック"
 "のアプローチを採用しているためです)。このため、\\ ``setup:``\\ ブロックで"
-"宣言した相互作用は決して評価されることがありません。"
+"宣言したインタラクションは決して評価されることがありません。"

 # cbc4d7b4da774f2bbf80c1bf20bf526e
 #: ../../interaction_based_testing.rst:623
@@ -1202,7 +1203,7 @@ msgid ""
 "Mocking and stubbing of the same method call has to happen in the same "
 "interaction."
 msgstr ""
-"同じメソッドに対するモックとスタブは同じ相互作用として"
+"同じメソッドに対するモックとスタブは同じインタラクションとして"
 "宣言しなければなりません。"

 # 665c938e1ff047d19f8e8a50f468bbdd
@@ -1240,7 +1241,7 @@ msgid ""
 msgstr ""
 "モックオブジェクトはモック、スタブの両方を行うことができましたが、"
 "スタブオブジェクトはスタブのみが行えます。"
-"相互作用の機能を制限することで、読み手に対して役割を明確にできます。"
+"インタラクションの機能を制限することで、読み手に対して役割を明確にできます。"

 # f68762c988344c7a935bea55e121fd95
 #: ../../interaction_based_testing.rst:646
@@ -1248,7 +1249,7 @@ msgid ""
 "If a stub invocation matches a *mandatory* interaction (like ``1 * foo.bar()"
 "``), an ``InvalidSpecException`` is thrown."
 msgstr ""
-"もしスタブオブジェクトで相互作用を定義した場合(\\ ``1 * foo.bar()``\\ のような)は"
+"もしスタブオブジェクトでインタラクションを定義した場合(\\ ``1 * foo.bar()``\\ のような)は"
 "\\ ``InvalidSpecException``\\ がスローされます。 "

 # 0b24002010864cf1abe733392c4a1364
@@ -1292,8 +1293,8 @@ msgid ""
 "interactions at mock creation time "
 "<DeclaringInteractionsAtMockCreationTime>` particularly attractive::"
 msgstr ""
-"スタブは\\ :ref:`モック作成時の相互作用宣言<DeclaringInteractionsAtMockCreationTime>`\\ "
-"と同じように相互作用の固定セットを持つこともできます。"
+"スタブは\\ :ref:`モック作成時のインタラクション宣言<DeclaringInteractionsAtMockCreationTime>`\\ "
+"と同じようにインタラクションの固定セットを持つこともできます。"

 # 0ef90c7c6fd64d84905d7e68d3ad1720
 #: ../../interaction_based_testing.rst:668
@@ -1369,7 +1370,7 @@ msgstr ""
 msgid ""
 "When stubbing a method on a spy, the real method no longer gets called::"
 msgstr ""
-"またスパイでメソッドをスタブすると、実際のメソッドが呼ばれなくなります。"
+"またスパイでメソッドをスタビングと、実際のメソッドが呼ばれなくなります。"

 # bbe7c076e6f34ec5af6168922b85a117
 #: ../../interaction_based_testing.rst:694
@@ -1457,7 +1458,7 @@ msgstr ""
 # d18076b55d31404bb35db43d0806a1ed
 #: ../../interaction_based_testing.rst:744
 msgid "Mocking Dynamic Methods"
-msgstr "動的メソッドをモックする"
+msgstr "動的メソッドをモッキング"

 # 1fc8b29bc2f948f7ad01ead99577754d
 #: ../../interaction_based_testing.rst:746
@@ -1472,7 +1473,7 @@ msgstr ""
 # a4e7a9a6e21041e88190eedfd6dea20b
 #: ../../interaction_based_testing.rst:756
 msgid "Mocking All Instances of a Type"
-msgstr "任意の型すべてのインスタンスをモックする"
+msgstr "任意の型すべてのインスタンスをモッキング"

 # b39cb451adf843acb497dd91295819e0
 #: ../../interaction_based_testing.rst:760
@@ -1501,7 +1502,7 @@ msgstr ""
 "その次に、この本物のsubscriber実装の型を指定してグローバルモックを作成します。"
 "このようにすることで実際のsubscriberに対する全てのメソッド呼び出しが、"
 "モックオブジェクトへ送られます。また、モックオブジェクトのインスタンスは"
-"publisherに設定していません。このモックオブジェクトは相互作用を宣言するためだけに使用します。"
+"publisherに設定していません。このモックオブジェクトはインタラクションを宣言するためだけに使用します。"

 # aea9e744fecf4810ba59e56bcb4d5f23
 #: ../../interaction_based_testing.rst:780
@@ -1522,7 +1523,7 @@ msgid ""
 msgstr ""
 "グローバルモックは全てのインスタンスに影響を与えますが、グローバルに使用する場合は\\ ``GroovySpy``\\ "
 "も非常に便利です。これは、必要な部分の動作だけ変更を行い、"
-"相互作用が\\ *一致しない*\\ 場合は実際のメソッドを実行することが可能です。"
+"インタラクションが\\ *一致しない*\\ 場合は実際のメソッドを実行することが可能です。"
 "また、呼び出しの確認もできます。"

 # 83b0129da7344c0fb5a41786a160e744
@@ -1544,7 +1545,7 @@ msgstr ""
 # db7c1be6744f4a09b3668274410f79ab
 #: ../../interaction_based_testing.rst:798
 msgid "Mocking Constructors"
-msgstr "コンストラクタをモックする"
+msgstr "コンストラクタをモッキング"

 # 54b151d48ba94e53bb175fb141ce367d
 #: ../../interaction_based_testing.rst:802
@@ -1573,7 +1574,7 @@ msgstr ""
 # d7a210665d22470086bc7deb90dc854f
 #: ../../interaction_based_testing.rst:819
 msgid "Mocking Static Methods"
-msgstr "Staticメソッドをモックする"
+msgstr "Staticメソッドをモッキング"

 # 1ea4c3fa67714fb7af1236f79362daf4
 #: ../../interaction_based_testing.rst:823
@@ -1682,7 +1683,7 @@ msgid ""
 "To learn more about interaction-based testing, we recommend the following "
 "resources:"
 msgstr ""
-"相互作用中心のテストについて、次の情報を参照することをおすすめします。"
+"インタラクション中心のテストについて、次の情報を参照することをおすすめします。"

 # d13528aa0fcf4ca2b5722677a0ca97ce
 #: ../../interaction_based_testing.rst:886
@@ -1708,7 +1709,7 @@ msgstr ""
 msgid ""
 "Paper from the OOPSLA2004 conference that explains how to do mocking *right*."
 msgstr ""
-"どのように\\ *適切*\\ にモックするか説明した、OOPSLA2004カンファレンスの資料"
+"どのように\\ *適切*\\ にモッキングか説明した、OOPSLA2004カンファレンスの資料"

 # dcb9e04f97104827a5c9f4bae686cf4c
 #: ../../interaction_based_testing.rst:894