NetBeans IDEでのJunitテストの記述

このチュートリアルでは、NetBeans IDEでJUnit単体テストを記述および実行するための基本情報を紹介します。アプリケーションのテストは開発サイクルに不可欠な部分であり、単体テストの記述および管理はソース・コード内の個々のメソッドが正しく動作することを確実にするために役立ちます。JUnit単体テスト・フレームワークに対するIDEの統合サポートにより、JUnitテストとテスト・スイートを迅速かつ容易に作成することができます。

このチュートリアルでは、Javaクラス・ライブラリ・プロジェクト用の、JUnit 3およびJUnit 4という単純な単体テストとテスト・スイートを作成します。チュートリアルの第一部では、JUnit 3でテストを作成する方法を説明します。第二部では、JUnitの注釈を使用して同じテストをJUnit 4で作成する方法を説明します。テストは同じであるためチュートリアルの両方の部分を完了する必要はありませんが、両方のバージョンでのテストの記述方法を見ることにより、JUnit 4で導入された変更のいくつかを確認できます。

JUnitの使用方法の詳細は、www.junit.orgを参照してください。

目次

このページの内容は、NetBeans IDE 7.2、7.3および7.4に適用されます

このチュートリアルに従うには、次のソフトウェアとリソースが必要です。

ソフトウェアまたはリソース 必須バージョン
NetBeans IDE 7.1、7.2、7.3および7.4
Java Development Kit (JDK) バージョン6または7
JUnitSampleSolプロジェクト ダウンロード

プロジェクトの作成

このチュートリアルを完了するには、最初にJUnit-SampleというJavaクラス・ライブラリ・プロジェクトを作成します。プロジェクトを作成した後、サンプル・プロジェクトJUnitSampleSolの2つのクラスを、プロジェクトJUnit-Sampleにコピーします。

Javaクラス・ライブラリ・プロジェクトの作成

  1. メイン・メニューから「ファイル」>「新規プロジェクト」を選択します。
  2. 「Java」カテゴリから「Javaクラス・ライブラリ」を選択し、「次」をクリックします。
  3. プロジェクトとして「JUnit-Sample」と入力し、プロジェクトの場所を設定します。
  4. 専用フォルダを使用するオプションが選択されている場合は選択を解除します。

    このチュートリアルでは、ライブラリを他のユーザーまたはプロジェクトと共有する必要がないので、プロジェクト・ライブラリを専用のフォルダにコピーする理由はほとんどありません。

    「終了」をクリックします。

JUnitテストを初めて作成すると、IDEからバージョンを選択するよう求められ、その後に「テスト・ライブラリ」ノードとJUnitライブラリが追加されます。

ソリューション・プロジェクトのダウンロード

このチュートリアルで使用するプロジェクトJUnitSampleSolは、次の方法でダウンロードできます。

  • 終了したプロジェクトのZIPアーカイブをダウンロードします。
  • 次の手順を実行して、プロジェクト・ソースをNetBeansのサンプルからチェックアウトします。
    1. メイン・メニューから「チーム」>「Subversion」>「チェックアウト」を選択します。
    2. 「チェックアウト」ダイアログ・ボックスで次のリポジトリURLを入力します。
      https://svn.netbeans.org/svn/samples~samples-source-code
      「次」をクリックします。
    3. 「チェックアウトするフォルダ」パネルで、「参照」をクリックして「リポジトリ・フォルダを参照」ダイアログ・ボックスを開きます。
    4. ルート・ノードを展開し、samples/java/JUnitSampleSolを選択します。「OK」をクリックします。
    5. ソースのローカル・フォルダを指定します。「終了」をクリックします。

      「終了」をクリックすると、IDEではローカル・フォルダがSubversionリポジトリとして初期化され、プロジェクト・ソースがチェックアウトされます。

    6. チェックアウトが完了するときに表示されるダイアログで、「プロジェクトを開く」をクリックします。

    Subversionのインストールの詳細は、NetBeans IDEでのSubversionガイドSubversionの設定の項を参照してください。

注意:IDEのインストール時にJUnitプラグインをインストールしなかった場合は、NetBeansプロジェクトを開いたときに、JUnitライブラリへの参照を解決するためにJUnitプラグインをインストールするように求められます。

Javaクラスの作成

この課題では、JUnitSampleSolサンプル・プロジェクトからUtils.javaファイルおよびVectors.javaファイルを、作成したクラス・ライブラリ・プロジェクトにコピーします。

  1. 「プロジェクト」ウィンドウで、JUnit-Sampleプロジェクトの「ソース・パッケージ」ノードを右クリックし、ポップアップ・メニューから「新規」>「Javaパッケージ」を選択します。
  2. パッケージ名として「sample」と入力します。「終了」をクリックします。
  3. JUnitSampleSolプロジェクトを開き(まだ開いていない場合)、「プロジェクト」ウィンドウで「ソース・パッケージ」ノードを展開します。
    「プロジェクト」ウィンドウのスクリーンショット
  4. JUnitSampleSolプロジェクト内のクラスUtils.javaVectors.javaをコピーし、それらをJUnit-Sample内のsampleソース・パッケージに貼り付けます。

クラスのソース・コードを見ると、Utils.javaに3つのメソッド(computeFactorialconcatWords、およびnormalizeWord)があり、Vectors.javaに2つのメソッド(equalおよびscalarMultiplication)があることがわかります。次の手順では、各クラス用のテスト・クラスを作成し、メソッド用にいくつかのテスト・クラスを記述します。

注意:JUnitSampleSolプロジェクトは必要がなくなったため閉じてかまいません。JUnitSampleSolプロジェクトには、このドキュメントで説明されているすべてのテストが含まれています。

JUnit 3単体テストの記述

チュートリアルのこの部分では、Vectors.javaクラスおよびUtils.javaクラス用の基本的なJUnit 3単体テストを作成します。IDEを使用して、プロジェクト内のクラスに基づいたスケルトン・テスト・クラスを作成します。次に、生成されたテスト・メソッドを変更し、新しいテスト・メソッドを追加します。

IDEを使用して初めてプロジェクト用のテストを作成する場合、JUnitバージョンの選択を求めるメッセージが表示されます。選択したバージョンがデフォルトのJUnitバージョンになり、以降のすべてのテストおよびテスト・スイートがそのバージョンで生成されます。

Vectors.java用のテスト・クラスの作成

この課題では、Vectors.java用のJUnitテスト・スケルトンを作成します。また、テスト・フレームワークとして「JUnit」を、バージョンとして「JUnit 3」を選択します。

注意:7.1以前のNetBeans IDEを使用している場合は、JUnitがデフォルトで指定されるため、テスト・フレームワークを指定する必要はありません。NetBeans IDE 7.2では、テスト・フレームワークとしてJUnitまたはTestNGを指定するオプションがあります。

  1. Vectors.javaを右クリックし、「ツール」>「テストを作成」を選択します。
  2. 「テストを作成」ダイアログで、テスト・クラスの名前をVectorsJUnit3Testに変更します。

    テスト・クラスの名前を変更するときは、名前が変更されることを警告するメッセージが表示されます。デフォルト名は、テスト対象のクラス名をベースに、末尾に「Test」を追加したものです。たとえば、MyClass.javaクラスの場合、テスト・クラスのデフォルト名は「MyClassTest.java」です。通常はデフォルト名をそのまま使用するのが最適ですが、このチュートリアルでは、JUnit 4テストも同じパッケージ内に作成し、テスト・クラスの名前は一意にする必要があるため、名前を変更します。

  3. 「フレームワーク」ドロップダウン・リストで「JUnit」を選択します。
  4. 「テスト初期化」および「テスト終了」を選択解除します。「OK」をクリックします。
    「JUnitのバージョンを選択」ダイアログ
  5. 「JUnitのバージョンを選択」ダイアログ・ボックスで「JUnit 3.x」を選択します。
    「JUnitのバージョンを選択」ダイアログ

    JUnit 3.xを選択すると、プロジェクトにJUnit 3ライブラリが追加されます。

    「選択」をクリックすると、IDEによって、「プロジェクト」ウィンドウ内の「テスト・パッケージ」ノードの下にあるsampleパッケージ内にVectorsJUnit3Test.javaテスト・クラスが作成されます。

    「プロジェクト」ウィンドウのスクリーンショット

    プロジェクトには、テストを作成するためのテスト・パッケージ用ディレクトリが必要です。テスト・パッケージ・ディレクトリのデフォルトの場所はプロジェクトのルート・レベルですが、プロジェクトのタイプに応じて、プロジェクトの「プロパティ」ダイアログでディレクトリに別の場所を指定できます。

    生成したテスト・クラスVectorsJUnit3Test.javaをエディタで表示すると、次のテスト・クラスがequalメソッドとscalarMultiplicationメソッドに対するテスト・メソッドとともに生成されたことがわかります。

    public class VectorsJUnit3Test extends TestCase {
        /**
         * Test of equal method, of class Vectors.
         */
        public void testEqual() {
            System.out.println("equal");
            int[] a = null;
            int[] b = null;
            boolean expResult = false;
            boolean result = Vectors.equal(a, b);
            assertEquals(expResult, result);
            // TODO review the generated test code and remove the default call to fail.
            fail("The test case is a prototype.");
        }
    
        /**
         * Test of scalarMultiplication method, of class Vectors.
         */
        public void testScalarMultiplication() {
            System.out.println("scalarMultiplication");
            int[] a = null;
            int[] b = null;
            int expResult = 0;
            int result = Vectors.scalarMultiplication(a, b);
            assertEquals(expResult, result);
            // TODO review the generated test code and remove the default call to fail.
            fail("The test case is a prototype.");
        }
    }

生成された各テストのメソッド本体は、ガイドとしてのみ用意されており、実際のテスト・ケースにするには変更する必要があります。コードを生成しない場合は、「テストを作成」ダイアログの「デフォルトのメソッド本体」を選択解除します。

IDEがテスト・メソッドの名前を生成する場合、各メソッド名の先頭に「test」が付加されます。これは、JUnit 3ではテストを識別するために命名規則とリフレクションが使用されるためです。テスト・メソッドを識別するために、各テスト・メソッドは「test<NAME>」という構文に従う必要があります。

注意:JUnit 4では注釈を使用してテスト・メソッドを識別できるため、このテスト・メソッドの命名構文を使用する必要がなくなり、テスト・クラスはTestCaseを拡張する必要がなくなりました。

Vectors.java用のテスト・メソッドの記述

この課題では、生成したテスト・メソッドを変更してテストが機能するようにし、デフォルトの出力メッセージを変更します。テストを実行するために出力メッセージを変更する必要はありませんが、「JUnitテスト結果」出力ウィンドウに表示される結果を識別するのに役立つよう、出力を変更します。

  1. エディタでVectorsJUnit3Test.javaを開きます。
  2. printlnの値を変更し、生成された変数を除去することによって、testScalarMultiplicationのテスト・スケルトンを変更します。テスト・メソッドは次のようになるはずです(太字部分が変更箇所)。
    public void testScalarMultiplication() {
        System.out.println("* VectorsJUnit3Test: testScalarMultiplication()");
        assertEquals(expResult, result);
    }
  3. ここで、メソッドをテストするためのアサーションを追加します。
    public void testScalarMultiplication() {
        System.out.println("* VectorsJUnit3Test: testScalarMultiplication()");
        assertEquals(  0, Vectors.scalarMultiplication(new int[] { 0, 0}, new int[] { 0, 0}));
        assertEquals( 39, Vectors.scalarMultiplication(new int[] { 3, 4}, new int[] { 5, 6}));
        assertEquals(-39, Vectors.scalarMultiplication(new int[] {-3, 4}, new int[] { 5,-6}));
        assertEquals(  0, Vectors.scalarMultiplication(new int[] { 5, 9}, new int[] {-9, 5}));
        assertEquals(100, Vectors.scalarMultiplication(new int[] { 6, 8}, new int[] { 6, 8}));
    }

    このテスト・メソッドでは、JUnitのassertEqualsメソッドが使用されます。アサーションを使用するには、入力変数と、期待する結果を指定します。テストに合格するには、テスト済メソッドを実行したときに、テスト・メソッドが供給した変数に基づいて、期待されるすべての結果を正常に返す必要があります。様々な考えられる並べ替えを実行するため、十分な数のアサーションを追加するようにしてください。

  4. 生成されたメソッド本体を削除し、次のprintlnを追加することによって、testEqualのテスト・スケルトンを変更します。
        System.out.println("* VectorsJUnit3Test: testEqual()");

    テスト・メソッドは次のようになるはずです。

    public void testEqual() {
        System.out.println("* VectorsJUnit3Test: testEqual()");
    }
  5. 次のアサーションを追加することによってtestEqualメソッドを変更します(太字部分が変更箇所)。
    public void testEqual() {
        System.out.println("* VectorsJUnit3Test: testEqual()");
        assertTrue(Vectors.equal(new int[] {}, new int[] {}));
        assertTrue(Vectors.equal(new int[] {0}, new int[] {0}));
        assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0, 0}));
        assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 0}));
        assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5, 6, 7}));
    
        assertFalse(Vectors.equal(new int[] {}, new int[] {0}));
        assertFalse(Vectors.equal(new int[] {0}, new int[] {0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0, 0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0}));
        assertFalse(Vectors.equal(new int[] {0}, new int[] {}));
    
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 1}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 1, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {1, 0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[] {0, 0, 3}));
    }

    このテストはJUnitのassertTrueメソッドとassertFalseメソッドを使用して、考えられる様々な結果をテストします。このメソッドのテストに合格するには、assertTrueがすべてtrue、assertFalseがすべてfalseである必要があります。

  6. 変更を保存します。

比較: Vectors.java用のテスト・メソッドの記述(JUnit 4)

Utils.java用のテスト・クラスの作成

ここで、Utils.javaのテスト・スケルトンを作成します。前の課題でテストを作成したとき、JUnitのバージョンを確認するメッセージが表示されました。今回はバージョンの選択を求めるメッセージは表示されません。

  1. Utils.javaを右クリックし、「ツール」>「テストを作成」を選択します。
  2. 「フレームワーク」ドロップダウン・リストで「JUnit」が選択されていない場合は選択します。
  3. ダイアログ・ボックスで「テスト初期化」および「テスト終了」が選択されていない場合は選択します。
  4. 「テストを作成」ダイアログ・ボックスで、テスト・クラスの名前をUtilsJUnit3Testに変更します。「OK」をクリックします。

「OK」をクリックすると、「テスト・パッケージ」のsamplesディレクトリに、テスト・ファイルUtilsJUnit3Test.javaが作成されます。Utils.java内にあるメソッド用にtestComputeFactorialtestConcatWords、およびtestNormalizeWordのテスト・スケルトンを作成する以外に、テスト初期化メソッドsetUpおよびテスト終了メソッドtearDownも作成されます。

Utils.java用のテスト・メソッドの記述

この課題では、共通のJUnitテスト要素の一部を示す、いくつかのテスト・ケースを追加します。一部のメソッドはデフォルトで出力をプリントしないため、printlnもメソッドに追加します。printlnをメソッドに追加することで、メソッドが実行されたかどうか、どの順番でメソッドが実行されたかを、後でJUnitテスト結果ウィンドウで確認できます。

テスト初期化およびテスト終了

setUpメソッドおよびtearDownメソッドは、テスト条件を初期化および終了するために使用されます。Utils.javaのテストにsetUpメソッドとtearDownメソッドは必要ありませんが、ここではこれらのメソッドの機能を示すために使用します。

setUpメソッドはテスト初期化メソッドであり、テスト・クラスの各テスト・ケースの前に実行されます。テストの実行にテスト初期化メソッドは必須ではありませんが、テストの実行前に一部の変数を初期化する必要がある場合は、テスト初期化メソッドを使用します。

tearDownメソッドはテスト終了メソッドであり、テスト・クラスの各テスト・ケースの後に実行されます。テストの実行にテスト終了メソッドは必須ではありませんが、テスト・ケースの実行時に求められたデータをクリーン・アップするために終了メソッドが必要になる場合があります。

  1. 次の変更(太字で表示)を実行して、各メソッドにprintlnを追加します。
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        System.out.println("* UtilsJUnit3Test: setUp() method");
    }
    
    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        System.out.println("* UtilsJUnit3Test: tearDown() method");
    }

    テストを実行すると、各メソッドのprintlnテキストが「JUnitテスト結果」出力ウィンドウに表示されます。printlnを追加しないと、メソッドが実行されたことを示す出力は表示されません。

単純なアサーションを使用したテスト

この単純なテスト・ケースでは、concatWordsメソッドをテストします。生成されたテスト・メソッドのtestConcatWordsを使用するかわりに、単一の単純なアサーションを使用してメソッドが文字列を正しく連結するかどうかをテストする、testHelloWorldという新しいテスト・メソッドを追加します。テスト・ケースのassertEqualsでは、予想した結果と実際の結果が同じであるかどうかをテストするために、構文assertEquals(EXPECTED_RESULT, ACTUAL_RESULT)が使用されます。この例では、concatWordsメソッドへの入力が「Hello」、「,」、「world」および「!」の場合、予想結果は「Hello, world!」と同じになるはずです。

  1. UtilsJUnit3Test.java内の生成されたテスト・メソッドtestConcatWordsを削除します。
  2. concatWordsメソッドをテストするため、次のメソッドを追加します。
    public void testHelloWorld() {
        assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));
    }
  3. テストに関するテキストを「JUnitテスト結果」ウィンドウに表示するため、println文を追加します。
    public void testHelloWorld() {
        System.out.println("* UtilsJUnit3Test: test method 1 - testHelloWorld()");
        assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));

比較: 単純なアサーションを使用したテスト(JUnit 4)

タイム・アウトを使用したテスト

このテストでは、メソッドの完了までに時間がかかりすぎているかどうかを確認する方法を示します。メソッドの時間がかかりすぎている場合は、テスト・スレッドが割込みされ、テストは失敗します。テストでは時間制限を指定できます。

テスト・メソッドにより、Utils.javacomputeFactorialメソッドが呼び出されます。computeFactorialメソッドは正しいと想定できますが、ここでテストするのは、計算が1000ミリ秒以内に完了するかどうかです。computeFactorialスレッドおよびテスト・スレッドは同時に開始されます。テスト・スレッドは1000ミリ秒後に停止し、computeFactorialスレッドが先に完了しないかぎり、TimeoutExceptionをスローします。メッセージを追加すると、TimeoutExceptionがスローされたときにメッセージが表示されます。

  1. 生成されたテスト・メソッドtestComputeFactorialを削除します。
  2. ランダムに生成された数字の階乗を計算するtestWithTimeoutメソッドを追加します。
    public void testWithTimeout() throws InterruptedException, TimeoutException {
        final int factorialOf = 1 + (int) (30000 * Math.random());
        System.out.println("computing " + factorialOf + '!');
    
        Thread testThread = new Thread() {
            public void run() {
                System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
            }
        };
    }
  3. java.util.concurrent.TimeoutExceptionをインポートするために、インポートを修正します。
  4. テストの実行に時間がかかりすぎる場合にスレッドが割込みされてメッセージが表示されるように、次のコード(太字で表示)をメソッドに追加します。
        Thread testThread = new Thread() {
            public void run() {
                System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
            }
        };
    
        testThread.start();
        Thread.sleep(1000);
        testThread.interrupt();
    
        if (testThread.isInterrupted()) {
            throw new TimeoutException("the test took too long to complete");
        }
    }

    タイム・アウトがスローされる前にミリ秒の数字を変更するには、Thread.sleep行を変更します。

  5. テストに関するテキストを「JUnitテスト結果」ウィンドウに出力するには、次のprintln(太字で表示)を追加します。
    public void testWithTimeout() throws InterruptedException, TimeoutException {
        System.out.println("* UtilsJUnit3Test: test method 2 - testWithTimeout()");
        final int factorialOf = 1 + (int) (30000 * Math.random());
        System.out.println("computing " + factorialOf + '!');
                

比較: タイム・アウトを使用したテスト(JUnit 4)

予想される例外のテスト

このテストでは、予想される例外のテスト方法を示します。このメソッドは、予想される指定の例外がスローされない場合、失敗します。この例では、入力変数が負の数(-5)の場合に、computeFactorialメソッドがIllegalArgumentExceptionをスローするかどうかをテストします。

  1. computeFactorialメソッドを呼び出す次のtestExpectedExceptionメソッドを、-5の入力とともに追加します。
    public void testExpectedException() {
        try {
            final int factorialOf = -5;
            System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
            fail("IllegalArgumentException was expected");
        } catch (IllegalArgumentException ex) {
        }
    }
  2. テストに関するテキストを「JUnitテスト結果」ウィンドウに出力するには、次のprintln(太字で表示)を追加します。
    public void testExpectedException() {
        System.out.println("* UtilsJUnit3Test: test method 3 - testExpectedException()");
        try {

比較: 予想される例外のテスト(JUnit 4)

テストの無効化

このテストでは、テスト・メソッドを一時的に無効にする方法を示します。JUnit 3では、名前の先頭がtestでないメソッドはテスト・メソッドとして認識されません。この例では、テスト・メソッドの名前の前にDISABLED_を付加して無効にします。

  1. 生成されたテスト・メソッドtestNormalizeWordを削除します。
  2. 次のテスト・メソッドをテスト・クラスに追加します。
    public void testTemporarilyDisabled() throws Exception {
        System.out.println("* UtilsJUnit3Test: test method 4 - checkExpectedException()");
        assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308"));
    }

    テスト・クラスを実行すると、テスト・メソッドtestTemporarilyDisabledが実行されます。

  3. テスト・メソッドの名前の先頭にDISABLED_(太字で表示)を付加します。
    public void DISABLED_testTemporarilyDisabled() throws Exception {
        System.out.println("* UtilsJUnit3Test: test method 4 - checkExpectedException()");
        assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308"));
    }

比較: テストの無効化(JUnit 4)

これでテストが記述されたので、テストを実行し、テスト出力を「JUnitテスト結果」ウィンドウで確認できます。

テストの実行

JUnitテストを実行すると、結果がIDEの「テスト結果」ウィンドウに表示されます。個々のJUnitテスト・クラスを実行するか、またはメイン・メニューから「実行」>「PROJECT_NAMEのテスト」を選択して、プロジェクトのすべてのテストを実行できます。「実行」>「テスト」を選択すると、「テスト・パッケージ」フォルダにあるすべてのテスト・クラスが実行されます。個々のテスト・クラスを実行するには、「テスト・パッケージ」ノードのテスト・クラスを右クリックし、「ファイルを実行」を選択します。

  1. メイン・メニューで「実行」>「メイン・プロジェクトとして設定」を選択し、JUnit-Sampleプロジェクトを選択します。
  2. メイン・メニューから「実行」>「プロジェクト(JUnit-Sample)をテスト」を選択します。
  3. 「ウィンドウ」>「IDEツール」>「テスト結果」を選択して、「テスト結果」ウィンドウを開きます。

テストの実行時、「JUnitテスト結果」ウィンドウに次の結果のいずれかが表示されます。

「JUnitテスト結果」ウィンドウのスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、プロジェクトがすべてのテストに合格したことがわかります。左ペインには個々のテスト・メソッドの結果が表示され、右ペインにはテスト出力が表示されます。出力を確認すると、テストが実行された順序がわかります。各テスト・メソッドに追加したprintlnにより、テストの名前が出力ウィンドウに出力されます。UtilJUnit3Testでは、各テスト・メソッドの前にsetUpメソッドが実行されたこと、および各メソッドの後にtearDownメソッドに実行されたことも確認できます。

「JUnitテスト結果」ウィンドウのスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、プロジェクトがテストの1つに失敗したことがわかります。testTimeoutメソッドの完了に時間がかかりすぎ、テスト・スレッドが割込みされたため、テストが失敗しました。ランダムに生成された数字(22991)の階乗の計算に1000ミリ秒以上かかりました。

単体テスト・クラス作成後の次の手順は、テスト・スイートの作成です。指定されたテストをグループとして実行し、各テストを個々に実行しなくて済むようにする方法については、JUnit 3テスト・スイートの作成を参照してください。

JUnit 4テストの記述

この課題では、Vectors.javaクラスとUtils.javaクラス用のJUnit 4単体テストを作成します。JUnit 4のテスト・ケースはJUnit 3のテスト・ケースと同じですが、テストを記述する構文が簡素化されています。

IDEのウィザードを使用して、プロジェクト内のクラスに基づき、テスト・スケルトンを作成します。テスト・スケルトンを作成するためにIDEを初めて使用する際は、JUnitのバージョンを選択するよう求められます。

注意:テストのデフォルト・バージョンとしてすでにJUnit 3.xを選択している場合は、デフォルト・バージョンをJUnit 4.xに変更する必要があります。JUnitのデフォルト・バージョンを変更するには、「テスト・ライブラリ」ノードを展開し、JUnitライブラリを右クリックして「除去」を選択します。これで、「ライブラリの追加」ダイアログ・ボックスを使用してJUnit 4ライブラリを明示的に追加するか、または新しいテストの作成時にJUnitバージョンの選択を求められたときにバージョン4.xを選択することができます。JUnit 3テストを実行することは可能ですが、新しく作成されるテストではJUnit 4が使用されます。

Vectors.java用のテスト・クラスの作成

この課題では、Vectors.java用のJUnitテスト・スケルトンを作成します。

注意:7.1以前のNetBeans IDEを使用している場合は、JUnitがデフォルトで指定されるため、テスト・フレームワークを指定する必要はありません。NetBeans IDE 7.2では、テスト・フレームワークとしてJUnitまたはTestNGを指定するオプションがあります。

  1. Vectors.javaを右クリックし、「ツール」>「テストを作成」を選択します。
  2. 「テストを作成」ダイアログで、テスト・クラスの名前をVectorsJUnit4Testに変更します。

    テスト・クラスの名前を変更するときは、名前が変更されることを警告するメッセージが表示されます。デフォルト名は、テスト対象のクラス名をベースに、末尾に「Test」を追加したものです。たとえば、MyClass.javaクラスの場合、テスト・クラスのデフォルト名は「MyClassTest.java」です。JUnit 3とは異なり、JUnit 4ではテスト名の末尾に「Test」を付ける必要はありません。通常はデフォルト名をそのまま使用するのが最適ですが、このチュートリアルでは、すべてのJUnitテストを同じパッケージ内に作成するため、テスト・クラスの名前は一意にします。

  3. 「フレームワーク」ドロップダウン・リストで「JUnit」を選択します。
  4. 「テスト初期化」および「テスト終了」を選択解除します。「OK」をクリックします。
    JUnit 4の「テストを作成」ダイアログのスクリーンショット
  5. 「JUnitのバージョンを選択」ダイアログ・ボックスで「JUnit 4.x」を選択します。「選択」をクリックします。
    「JUnitのバージョンを選択」ダイアログ

「OK」をクリックすると、IDEによって、「プロジェクト」ウィンドウ内の「テスト・パッケージ」ノードの下にあるsampleパッケージ内にVectorsJUnit4Test.javaテスト・クラスが作成されます。

「プロジェクト」ウィンドウのスクリーンショット

注意:プロジェクトには、テストを作成するためのテスト・パッケージ用ディレクトリが必要です。テスト・パッケージ・ディレクトリのデフォルトの場所は、プロジェクトのルート・レベルですが、プロジェクトの「プロパティ」ダイアログでディレクトリ用の別の場所を指定することもできます。

エディタでVectorsJUnit3Test.javaを表示すると、テスト・メソッドのtestEqualtestScalarMultiplicationが生成されていることがわかります。VectorsJUnit4Test.javaでは、各テスト・メソッドに@Testという注釈が付きます。Vectors.java内のメソッド名に基づいてテスト・メソッドの名前が生成されますが、テスト・メソッドの名前の先頭にtestを付加する必要はありません。生成された各テスト・メソッドのデフォルトの本体はガイドとしてのみ用意され、実際のテスト・ケースになるように変更する必要があります。

メソッドの本体を生成しないようにするには、「テストを作成」ダイアログの「デフォルトのメソッド本体」を選択解除します。

また、次のテスト・クラスの初期化メソッドと終了メソッドが生成されました。

@BeforeClass
public static void setUpClass() throws Exception {
}

@AfterClass
public static void tearDownClass() throws Exception {
}

JUnit 4のテスト・クラスを作成するときに、クラスの初期化メソッドと終了メソッドがデフォルトで生成されます。注釈@BeforeClassおよび@AfterClassは、テスト・クラスの実行前後に実行する必要があるメソッドをマークするために使用されます。メソッドを使用してVectors.javaをテストする必要はないため、これらのメソッドは削除してかまいません。

「オプション」ウィンドウでJUnitオプションを構成することにより、デフォルトで生成されるメソッドを構成できます。

注意:JUnit 4テストでは、IDEによって、org.junit.Assert.*のための静的なインポート宣言がデフォルトで追加されることに注意してください。

Vectors.java用のテスト・メソッドの記述

この課題では、JUnitassertメソッドを使用してメソッドをテストし、テスト・メソッドの名前を変更するため、生成された各テスト・メソッドを変更します。JUnit 4では、テスト・メソッドが@Test注釈で示され、テスト・メソッド名の先頭にtestを付ける必要がないため、テスト・メソッド名を柔軟に指定できます。

  1. エディタでVectorsJUnit4Test.javaを開きます。
  2. メソッド名を変更し、printlnの値を変更して生成された変数を除去することによって、testScalarMultiplicationのテスト・メソッドを変更します。テスト・メソッドは次のようになるはずです(太字部分が変更箇所)。
    @Test
    public void ScalarMultiplicationCheck() {
        System.out.println("* VectorsJUnit4Test: ScalarMultiplicationCheck()");
        assertEquals(expResult, result);
    }

    注意:テストを記述する際に、プリントされた出力を変更する必要はありません。これはこの課題で行うため、テスト結果を出力ウィンドウで確認しやすくなります。

  3. ここで、メソッドをテストするためのアサーションを追加します。
    @Test
    public void ScalarMultiplicationCheck() {
        System.out.println("* VectorsJUnit4Test: ScalarMultiplicationCheck()");
        assertEquals(  0, Vectors.scalarMultiplication(new int[] { 0, 0}, new int[] { 0, 0}));
        assertEquals( 39, Vectors.scalarMultiplication(new int[] { 3, 4}, new int[] { 5, 6}));
        assertEquals(-39, Vectors.scalarMultiplication(new int[] {-3, 4}, new int[] { 5,-6}));
        assertEquals(  0, Vectors.scalarMultiplication(new int[] { 5, 9}, new int[] {-9, 5}));
        assertEquals(100, Vectors.scalarMultiplication(new int[] { 6, 8}, new int[] { 6, 8}));
    }

    このテスト・メソッドでは、JUnitassertEqualsメソッドを使用します。アサーションを使用するには、入力変数と、期待する結果を指定します。テストに合格するには、テスト済メソッドを実行したときに、テスト・メソッドが供給した変数に基づいて、期待されるすべての結果を正常に返す必要があります。様々な考えられる並べ替えを実行するため、十分な数のアサーションを追加するようにしてください。

  4. testEqualテスト・メソッドの名前をequalsCheckに変更します。
  5. equalsCheckテスト・メソッドの生成されたメソッドの本文を削除します。
  6. 次のprintlnequalsCheckテスト・メソッドに追加します。
    System.out.println("* VectorsJUnit4Test: equalsCheck()");

    テスト・メソッドは次のようになるはずです。

    @Test
    public void equalsCheck() {
        System.out.println("* VectorsJUnit4Test: equalsCheck()");
    }
  7. 次のアサーション(太字で表示)を追加することによって、equalsCheckメソッドを変更します。
    @Test
    public void equalsCheck() {
        System.out.println("* VectorsJUnit4Test: equalsCheck()");
        assertTrue(Vectors.equal(new int[] {}, new int[] {}));
        assertTrue(Vectors.equal(new int[] {0}, new int[] {0}));
        assertTrue(Vectors.equal(new int[] {0, 0}, new int[] {0, 0}));
        assertTrue(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 0}));
        assertTrue(Vectors.equal(new int[] {5, 6, 7}, new int[] {5, 6, 7}));
    
        assertFalse(Vectors.equal(new int[] {}, new int[] {0}));
        assertFalse(Vectors.equal(new int[] {0}, new int[] {0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0, 0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0}, new int[] {0}));
        assertFalse(Vectors.equal(new int[] {0}, new int[] {}));
    
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 0, 1}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {0, 1, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 0}, new int[] {1, 0, 0}));
        assertFalse(Vectors.equal(new int[] {0, 0, 1}, new int[] {0, 0, 3}));
    }

    このテストはJUnitのassertTrueメソッドとassertFalseメソッドを使用して、考えられる様々な結果をテストします。このメソッドのテストに合格するには、assertTrueがすべてtrue、assertFalseがすべてfalseである必要があります。

比較: Vectors.java用のテスト・メソッドの記述(JUnit 3)

Utils.java用のテスト・クラスの作成

ここで、Utils.javaのJUnitテスト・メソッドを作成します。前の課題でテスト・クラスを作成したとき、JUnitのバージョンを確認するメッセージが表示されました。すでにJUnitバージョンを選択したため、以降に作成されたすべてのJUnitテストはそのバージョンなので、今回はバージョンの選択を求めるメッセージは表示されません。

注意:バージョンとしてJUnit 4を選択してもJUnit 3のテストを記述して実行することはできますが、テスト・スケルトンの生成にはJUnit 4のテンプレートが使用されます。

  1. Utils.javaを右クリックし、「ツール」>「テストを作成」を選択します。
  2. 「フレームワーク」ドロップダウン・リストで「JUnit」が選択されていない場合は選択します。
  3. ダイアログ・ボックスで「テスト初期化」および「テスト終了」が選択されていない場合は選択します。
  4. 「テストを作成」ダイアログ・ボックスで、テスト・クラスの名前をUtilsJUnit4Testに変更します。「OK」をクリックします。

「OK」をクリックすると、IDEによって、「テスト・パッケージ」のsampleディレクトリ内にテスト・ファイルUtilsJUnit4Test.javaが作成されます。Utils.java内にあるメソッド用に、testComputeFactorialtestConcatWordstestNormalizeWordの各テスト・メソッドが生成されたことがわかります。テストおよびテスト・クラスに対して初期化メソッドと終了メソッドも生成されます。

Utils.java用のテスト・メソッドの記述

この課題では、JUnitで共通のテスト要素の一部を示すテスト・ケースを追加します。一部のメソッドは、メソッドが実行されたことやメソッドがテストに合格したことを示す出力を「JUnitテスト結果」ウィンドウにプリントしないため、メソッドにprintlnも追加します。printlnをメソッドに追加することで、メソッドが実行されたかどうか、およびどの順番でメソッドが実行されたかを確認できます。

テスト初期化およびテスト終了

Utils.java用のテスト・クラスを作成するとき、注釈付きの初期化メソッドと終了メソッドが生成されます。メソッド名には必須の命名規則がないため、任意の名前を付けることができます。

注意:Utils.javaのテストに初期化メソッドと終了メソッドは必要ありませんが、このチュートリアルではそれらの機能を示すために含めます。

JUnit 4では、次のタイプの初期化メソッドと終了メソッドをマークするために注釈を使用できます。

  • テスト・クラス初期化。@BeforeClass注釈により、メソッドがテスト・クラス初期化メソッドとしてマークされます。テスト・クラス初期化メソッドは、テスト・クラス内の他のメソッドの前に、1回のみ実行されます。たとえば、テスト初期化でデータベース接続を作成したり、各テスト・メソッドの前に新しい接続を作成するかわりに、テストを実行する前にテスト・クラス初期化を使用して接続を開きます。続いて、テスト・クラス終了を使用して接続を閉じます。
  • テスト・クラス終了。@AfterClass注釈により、メソッドがテスト・クラス終了メソッドとしてマークされます。テスト・クラス終了メソッドは、テスト・クラス内の他のすべてのメソッドが終了した後、1回のみ実行されます。
  • テスト初期化。@Before注釈により、メソッドがテスト初期化メソッドとしてマークされます。テスト初期化メソッドは、テスト・クラスの各テスト・ケースの前に実行されます。テストの実行にテスト初期化メソッドは必須ではありませんが、テストの実行前に一部の変数を初期化する必要がある場合は、テスト初期化メソッドを使用します。
  • テスト終了。@After注釈により、メソッドがテスト終了メソッドとしてマークされます。テスト終了メソッドは、テスト・クラスの各テスト・ケースの後に実行されます。テストの実行にテスト終了メソッドは必須ではありませんが、テスト・ケースの実行時に求められたデータをクリーン・アップするために終了メソッドが必要になる場合があります。

UtilsJUnit4Test.javaで、次の変更(太字で表示されています)を行います。

@BeforeClass
public static void setUpClass() throws Exception {
    System.out.println("* UtilsJUnit4Test: @BeforeClass method");
}

@AfterClass
public static void tearDownClass() throws Exception {
    System.out.println("* UtilsJUnit4Test: @AfterClass method");
}

@Before
public void setUp() {
    System.out.println("* UtilsJUnit4Test: @Before method");
}

@After
public void tearDown() {
    System.out.println("* UtilsJUnit4Test: @After method");
}

比較: テストの初期化および終了(JUnit 3)

テスト・クラスを実行すると、追加したprintlnテキストが「JUnitテスト結果」ウィンドウの出力ペインに表示されます。printlnを追加しない場合、初期化メソッドと終了メソッドが実行されたことを示す出力は表示されません。

単純なアサーションを使用したテスト

この単純なテスト・ケースでは、concatWordsメソッドをテストします。生成されたテスト・メソッドのtestConcatWordsを使用するかわりに、単一の単純なアサーションを使用してメソッドが文字列を正しく連結するかどうかをテストする、helloWorldCheckという新しいテスト・メソッドを追加します。テスト・ケースのassertEqualsでは、予想した結果と実際の結果が同じであるかどうかをテストするために、構文assertEquals(EXPECTED_RESULT, ACTUAL_RESULT)が使用されます。この例では、concatWordsメソッドへの入力が「Hello」、「,」、「world」および「!」の場合、予想結果は「Hello, world!」と同じになるはずです。

  1. 生成されたtestConcatWordsテスト・メソッドを削除します。
  2. Utils.concatWordsをテストするため、次のhelloWorldCheckメソッドを追加します。
    @Test
    public void helloWorldCheck() {
        assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));
    }
  3. テストに関するテキストを「JUnitテスト結果」ウィンドウに表示するため、println文を追加します。
    @Test
    public void helloWorldCheck() {
        System.out.println("* UtilsJUnit4Test: test method 1 - helloWorldCheck()");
        assertEquals("Hello, world!", Utils.concatWords("Hello", ", ", "world", "!"));

比較: 単純なアサーションを使用したテスト(JUnit 3)

タイム・アウトを使用したテスト

このテストでは、メソッドの完了までに時間がかかりすぎているかどうかを確認する方法を示します。メソッドの時間がかかりすぎている場合は、テスト・スレッドが割込みされ、テストは失敗します。テストでは時間制限を指定できます。

テスト・メソッドにより、Utils.javacomputeFactorialメソッドが呼び出されます。computeFactorialメソッドは正しいと想定できますが、ここでテストするのは、計算が1000ミリ秒以内に完了するかどうかです。これは、1000ミリ秒後にテスト・スレッドが割込みされることによって行います。スレッドが割込みされると、テスト・メソッドはTimeoutExceptionをスローします。

  1. 生成されたテスト・メソッドtestComputeFactorialを削除します。
  2. ランダムに生成された数字の階乗を計算するtestWithTimeoutメソッドを追加します。
    @Test
    public void testWithTimeout() {
        final int factorialOf = 1 + (int) (30000 * Math.random());
        System.out.println("computing " + factorialOf + '!');
        System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
    }
  3. タイム・アウトを設定し、メソッドの実行に時間がかかりすぎる場合にスレッドが割込みされるようにするには、次のコード(太字で表示)を追加します。
    @Test(timeout=1000)
    public void testWithTimeout() {
        final int factorialOf = 1 + (int) (30000 * Math.random());

    タイム・アウトが1000ミリ秒に設定されていることがわかります。

  4. テストに関するテキストを「JUnitテスト結果」ウィンドウに出力するには、次のprintln(太字で表示)を追加します。
    @Test(timeout=1000)
    public void testWithTimeout() {
        System.out.println("* UtilsJUnit4Test: test method 2 - testWithTimeout()");
        final int factorialOf = 1 + (int) (30000 * Math.random());
        System.out.println("computing " + factorialOf + '!');
                

比較: タイム・アウトを使用したテスト(JUnit 3)

予想される例外のテスト

このテストでは、予想される例外のテスト方法を示します。このメソッドは、予想される指定の例外がスローされない場合、失敗します。この例では、入力変数が負の数(-5)の場合に、computeFactorialメソッドがIllegalArgumentExceptionをスローするかどうかをテストします。

  1. computeFactorialメソッドを呼び出す次のtestExpectedExceptionメソッドを、-5の入力とともに追加します。
    @Test
    public void checkExpectedException() {
        final int factorialOf = -5;
        System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
    }
  2. テストがIllegalArgumentExceptionをスローするように指定するには、次のプロパティ(太字で表示)を@Test注釈に追加します。
    @Test(expected=IllegalArgumentException.class)
    public void checkExpectedException() {
        final int factorialOf = -5;
        System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
    }
  3. テストに関するテキストを「JUnitテスト結果」ウィンドウに出力するには、次のprintln(太字で表示)を追加します。
    @Test (expected=IllegalArgumentException.class)
    public void checkExpectedException() {
        System.out.println("* UtilsJUnit4Test: test method 3 - checkExpectedException()");
        final int factorialOf = -5;
        System.out.println(factorialOf + "! = " + Utils.computeFactorial(factorialOf));
    }

比較: 予想される例外のテスト(JUnit 3)

テストの無効化

このテストでは、テスト・メソッドを一時的に無効にする方法を示します。JUnit 4でテストを無効にするには、単純に@Ignore注釈を追加します。

  1. 生成されたテスト・メソッドtestNormalizeWordを削除します。
  2. 次のテスト・メソッドをテスト・クラスに追加します。
    @Test
    public void temporarilyDisabledTest() throws Exception {
        System.out.println("* UtilsJUnit4Test: test method 4 - checkExpectedException()");
        assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308"));
    }

    テスト・クラスを実行すると、テスト・メソッドtemporarilyDisabledTestが実行されます。

  3. テストを無効にするには、@Testの上に@Ignore注釈(太字で表示)を追加します。
    @Ignore
    @Test
    public void temporarilyDisabledTest() throws Exception {
        System.out.println("* UtilsJUnit4Test: test method 4 - checkExpectedException()");
        assertEquals("Malm\u00f6", Utils.normalizeWord("Malmo\u0308"));
    }
  4. org.junit.Ignoreをインポートするために、インポートを修正します。

比較: テストの無効化(JUnit 3)

これでテストが記述されたので、テストを実行し、テスト出力を「JUnitテスト結果」ウィンドウで確認できます。

テストの実行

アプリケーション全体または個々のファイルでJUnitテストを実行し、結果をIDEで確認できます。プロジェクトのすべての単体テストを最も簡単な方法で実行するには、メイン・メニューから「実行」>「<プロジェクト名>のテスト」を選択します。この方法を選択すると、「テスト・パッケージ」内のすべてのテストが実行されます。個々のテスト・クラスを実行するには、「テスト・パッケージ」ノードのテスト・クラスを右クリックし、「ファイルを実行」を選択します。

  1. 「プロジェクト」ウィンドウでUtilsJUnit4Test.javaを右クリックします。
  2. 「ファイルをテスト」を選択します。
  3. 「ウィンドウ」>「IDEツール」>「テスト結果」を選択して、「テスト結果」ウィンドウを開きます。

UtilsJUnit4Test.javaを実行するときは、テスト・クラス内のテストのみが実行されます。クラスがすべてのテストに合格すると、次のイメージに似た内容が「JUnitテスト結果」ウィンドウに表示されます。

「JUnitテスト結果」ウィンドウのスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、IDEによりUtils.javaでJUnitテストが実行されたこと、およびクラスがすべてのテストに合格したことがわかります。左ペインには個々のテスト・メソッドの結果が表示され、右ペインにはテスト出力が表示されます。出力を確認すると、テストが実行された順序がわかります。各テスト・メソッドに追加したprintlnにより、テストの名前が「テスト結果」ウィンドウおよび「出力」ウィンドウに出力されます。

UtilsJUnit4Testで、@BeforeClassという注釈が付いたテスト・クラス初期化メソッドが、他のメソッドより先に1回のみ実行されたことがわかります。@AfterClassという注釈が付いたテスト・クラス終了メソッドが、クラス内の他のすべてのメソッドが実行された後で最後に実行されました。@Beforeという注釈が付いたテスト初期化メソッドが各テスト・メソッドより先に実行されました。

「テスト結果」ウィンドウの左側にあるコントロールを使用すると、テストを簡単に再実行できます。フィルタを使用すると、すべてのテスト結果の表示と失敗したテストのみの表示を切り替えることができます。矢印を使用して、次の失敗または前の失敗にスキップできます。

「テスト結果」ウィンドウでテスト結果を右クリックすると、ポップアップ・メニューを使用してテストのソースに移動したり、テストを再度実行したり、テストをデバッグしたりできます。

単体テスト・クラス作成後の次の手順は、テスト・スイートの作成です。指定されたテストをグループとして実行し、各テストを個々に実行しなくて済むようにする方法については、JUnit 4テスト・スイートの作成を参照してください。

テスト・スイートの作成

プロジェクト用のテストを作成するときは通常、多数のテスト・クラスができます。テスト・クラスを個別に実行することも、プロジェクト内のすべてのテストをまとめて実行することもできます。多くの場合、テストのサブセットを実行するか、特定の順序でテストを実行します。これは、1つまたは複数のテスト・スイートを作成することで実現できます。たとえば、コードの特定の側面または特定の条件をテストするテスト・スイートを作成できます。

テスト・スイートとは、基本的にメソッドを持つクラスであり、特定のテスト・クラス、テスト・クラス内のテスト・メソッド、およびその他のテスト・スイートなどの指定したテスト・ケースを起動します。テスト・スイートはテスト・クラスの一部として含めることができますが、ベスト・プラクティスとしては、個々のテスト・スイート・クラスを作成することをお薦めします。

プロジェクト用のJUnit 3およびJUnit 4のテスト・スイートは、手動で作成することも、IDEが生成することもできます。IDEを使用してテスト・スイートを生成すると、デフォルトで、同じパッケージ内のすべてのテスト・クラスをテスト・スイートとして呼び出すコードが生成されます。テスト・スイートを作成した後、スイートの一部として実行するテストを指定するようにクラスを変更できます。

JUnit 3テスト・スイートの作成

テストのバージョンとしてJUnit 3を選択した場合、IDEではテスト・パッケージのテスト・クラスに基づいてJUnit 3テスト・スイートが生成されます。JUnit 3では、TestSuiteのインスタンスを作成し、各テストに対してaddTestメソッドを使用することによって、テスト・スイートに含めるテスト・クラスを指定します。

  1. 「プロジェクト」ウィンドウで「JUnit-Sample」プロジェクト・ノードを右クリックし、「新規」>「その他」を選択して新規ファイル・ウィザードを開きます。
  2. 「単体テスト」カテゴリで「テスト・スイート」を選択します。「次」をクリックします。
  3. 「クラス名」に「JUnit3TestSuite」と入力します。
  4. テスト・スイートを作成するため、テスト・パッケージ・フォルダのサンプル・フォルダにあるsampleパッケージを選択します。
  5. 「テスト初期化」および「テスト終了」を選択解除します。「終了」をクリックします。
    JUnitのテスト・スイート・ウィザードのスクリーンショット

    「終了」をクリックすると、sampleパッケージにテスト・スイート・クラスが作成され、クラスがエディタに表示されます。このテスト・スイートには次のコードが含まれます。

    public class JUnit3TestSuite extends TestCase {
        public JUnit3TestSuite(String testName) {
            super(testName);
        }
    
        public static Test suite() {
            TestSuite suite = new TestSuite("JUnit3TestSuite");
            return suite;
        }
    }
  6. suite()メソッドを変更して、このスイートの一部として実行されるテスト・クラスを追加します。
    public JUnit3TestSuite(String testName) {
        super(testName);
    }
    
    public static Test suite() {
        TestSuite suite = new TestSuite("JUnit3TestSuite");
        suite.addTest(new TestSuite(sample.VectorsJUnit3Test.class));
        suite.addTest(new TestSuite(sample.UtilsJUnit3Test.class));
        return suite;
    }
  7. 変更を保存します。

JUnit 4テスト・スイートの作成

テストのバージョンとしてJUnit 4を選択した場合、IDEではJUnit 4テスト・スイートを生成できます。JUnit 4は下位互換性があるので、JUnit 4とJUnit 3のどちらのテストを含むJUnit 4テスト・スイートも実行できます。JUnit 4のテスト・スイートでは、テスト・スイートに含めるテスト・クラスを@Suite注釈の値として指定します。

注意:JUnit 3のテスト・スイートをJUnit 4のテスト・スイートとして実行するには、JUnit 4.4以上が必要です。

  1. 「プロジェクト」ウィンドウでプロジェクト・ノードを右クリックし、「新規」>「その他」を選択して新規ファイル・ウィザードを開きます。
  2. 「単体テスト」カテゴリで「テスト・スイート」を選択します。「次」をクリックします。
  3. ファイル名に「JUnit4TestSuite」と入力します。
  4. テスト・スイートを作成するため、テスト・パッケージ・フォルダのサンプル・フォルダにあるsampleパッケージを選択します。
  5. 「テスト初期化」および「テスト終了」を選択解除します。「終了」をクリックします。

「終了」をクリックすると、sampleパッケージにテスト・スイート・クラスが作成され、クラスがエディタに表示されます。このテスト・スイートには次のようなコードが含まれます。

@RunWith(Suite.class)
@Suite.SuiteClasses(value={UtilsJUnit4Test.class, VectorsJUnit4Test.class})
public class JUnit4TestSuite {
}

このテスト・スイートを実行すると、IDEによって各テスト・クラスが、リストされている順序で実行されます。

テスト・スイートの実行

テスト・スイートは、個々のテスト・クラスを実行する場合と同じ方法で実行します。

  1. 「プロジェクト」ウィンドウで「テスト・パッケージ」ノードを展開します。
  2. テスト・スイート・クラスを右クリックし、「ファイルをテスト」を選択します。

テスト・スイートを実行すると、スイートに含まれるテストが一覧表示された順に実行されます。結果は「JUnitテスト結果」ウィンドウに表示されます。

JUnit 3テスト・スイートの「JUnitテスト結果」のスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、JUnit 3テスト・スイートのテスト結果がわかります。テスト・スイートによりUtilsJUnit3Testテスト・クラスとVectorsJUnit3Testテスト・クラスが単一のテストとして実行され、単一テストの結果として、テスト結果が左ペインに表示されました。右ペインの出力は、テストを個別に実行した場合と同じ内容です。

JUnit 4テスト・スイートの「JUnitテスト結果」のスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、JUnit 4テスト・スイートのテスト結果がわかります。テスト・スイートによりUtilsJUnit4Testテスト・クラスとVectorsJUnit4Testテスト・クラスが単一のテストとして実行され、単一のテストの結果としてテスト結果が左ペインに表示されました。右ペインの出力は、テストを個別に実行した場合と同じ内容です。

混合型のテスト・スイートの「JUnitテスト結果」のスクリーンショット

このイメージ(大きいイメージを表示するにはイメージをクリック)では、混合型のテスト・スイートのテスト結果がわかります。このテスト・スイートにはJUnit 4テスト・スイートとJUnit 3のテスト・クラスのうち1つが含まれています。テスト・スイートによりUtilsJUnit3Test.javaテスト・クラスとJUnit4TestSuite.javaテスト・クラスが単一のテストとして実行され、単一のテストの結果としてテスト結果が左ペインに表示されました。右ペインの出力は、テストを個別に実行した場合と同じ内容です。

要約

このチュートリアルでは、NetBeans IDEでJUnit単体テストとテスト・スイートを作成するための基本を紹介しました。IDEではJUnit 3およびJUnit 4がサポートされており、このドキュメントでは、テストの作成および実行をより簡素化するように設計されているJUnit 4での変更点をいくつか示しました。

このチュートリアルで示されているように、JUnit 4での主な改善点の1つは注釈のサポートです。JUnit 4では、注釈を使用して次を行うことができます。

  • 命名規則のかわりに@Test注釈を使用してテストを識別する
  • @Before注釈および@After注釈を使用して、setUpメソッドおよびtearDownメソッドを識別する
  • テスト・クラス全体に適用するsetUpメソッドおよびtearDownメソッドを識別する。@BeforeClassという注釈が付いたメソッドは、クラス内の任意のテスト・メソッドが実行される前に、1回のみ実行されます。@AfterClassという注釈が付いたメソッドも、すべてのテスト・メソッドが終了した後に、1回のみ実行されます。
  • 予期している例外を識別する
  • @Ignore注釈を使用して省略するテストを識別する
  • テストのタイム・アウト・パラメータを指定する

JUnitの使用およびJUnit 4でのその他の変更点に関する詳細は、次のリソースを参照してください。

コードのテストは、コードにわずかな変更を加えてもアプリケーションが壊れないことを確認するのに役立ちます。JUnitなどの自動テスト・ツールを使用するとテストのプロセスを合理化でき、テストを頻繁に行うことでコード・エラーを早期に発見できます。



関連項目

NetBeans IDEを使用したJavaアプリケーションの開発方法の詳細は、次のリソースを参照してください。

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo