MENU
  1. ホーム
  2. C++
  3. C++のアクセス指定子とユニットテストの関係を徹底解説

C++のアクセス指定子とユニットテストの関係を徹底解説

C++

C++のプログラムにおいて、アクセス指定子（public, protected, private）はクラスの設計やセキュリティにおいて重要な役割を果たします。しかし、ユニットテストを行う際にはこれらのアクセス指定子が障壁となることがあります。本記事では、アクセス指定子の基本からユニットテストへの影響、そして具体的なテスト手法までを詳しく解説します。

目次

アクセス指定子の基本

C++のアクセス指定子は、クラスのメンバー（データメンバーやメンバーファンクション）へのアクセスを制御するためのキーワードです。以下に、主要なアクセス指定子について説明します。

public

public指定子を付けたメンバーは、クラスの外部から自由にアクセスできます。これは、他のクラスや関数がこれらのメンバーに直接アクセスできることを意味します。

class MyClass {
public:
    int publicVar;
    void publicMethod() {}
};

protected

protected指定子を付けたメンバーは、同じクラスおよび派生クラス（サブクラス）からアクセス可能です。外部からはアクセスできません。

class BaseClass {
protected:
    int protectedVar;
};

class DerivedClass : public BaseClass {
    void accessProtectedVar() {
        protectedVar = 10; // OK
    }
};

private

private指定子を付けたメンバーは、同じクラスからのみアクセス可能です。派生クラスや外部からのアクセスはできません。

class MyClass {
private:
    int privateVar;
    void privateMethod() {}
};

publicアクセス指定子とユニットテスト

publicアクセス指定子は、クラスのメンバーを外部から直接アクセス可能にするため、ユニットテストを行う際に最も簡単な方法です。publicメンバーは、テストケースから直接アクセスできるため、特別な手法やトリックを必要としません。

publicメンバーのテスト

publicメンバーのテストは、通常の関数や変数と同様に行います。以下に、C++でpublicメンバーを持つクラスのユニットテストの例を示します。

#include <cassert>

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }
};

void testAdd() {
    Calculator calc;
    assert(calc.add(2, 3) == 5);
    assert(calc.add(-1, 1) == 0);
    assert(calc.add(0, 0) == 0);
}

int main() {
    testAdd();
    return 0;
}

この例では、Calculatorクラスのaddメソッドがpublicであるため、テスト関数testAddから直接呼び出して結果を検証できます。

publicメンバーの利点と欠点

  • 利点: publicメンバーはテストしやすく、直接アクセス可能なため、テストコードがシンプルになります。
  • 欠点: クラスの内部実装が公開されてしまうため、カプセル化が損なわれる可能性があります。

protectedアクセス指定子とユニットテスト

protectedアクセス指定子は、同じクラスとその派生クラスからのみアクセスできるメンバーを定義します。ユニットテストを行う際には、protectedメンバーにアクセスするための特別な手法が必要です。

派生クラスを利用したテスト

protectedメンバーをテストするための一般的な方法は、テスト用の派生クラスを作成することです。これにより、テストコードからprotectedメンバーにアクセスできます。

#include <cassert>

class Base {
protected:
    int protectedVar;

public:
    Base() : protectedVar(0) {}
    void setVar(int value) { protectedVar = value; }
};

class TestableBase : public Base {
public:
    int getProtectedVar() {
        return protectedVar;
    }
};

void testProtectedVar() {
    TestableBase testObj;
    testObj.setVar(10);
    assert(testObj.getProtectedVar() == 10);
}

int main() {
    testProtectedVar();
    return 0;
}

この例では、BaseクラスのprotectedメンバーprotectedVarをテストするために、TestableBaseという派生クラスを作成しています。TestableBaseクラスは、protectedメンバーにアクセスするメソッドを提供し、それを使ってテストを行います。

protectedメンバーの利点と欠点

  • 利点: クラスの内部実装をある程度隠蔽しつつ、テスト可能にすることができます。
  • 欠点: テスト用の派生クラスを作成する必要があり、テストコードが少し複雑になることがあります。

privateアクセス指定子とユニットテスト

privateアクセス指定子は、クラス内部でのみアクセス可能なメンバーを定義します。ユニットテストを行う際に、privateメンバーに直接アクセスすることはできません。そのため、テストのための特別な手法や工夫が必要になります。

アクセスするための工夫

privateメンバーをテストするための一般的な方法は、フレンド関数を利用することです。フレンド関数は、クラスのprivateメンバーにアクセスすることを許可されている関数です。

#include <cassert>

class MyClass {
private:
    int privateVar;

public:
    MyClass() : privateVar(0) {}

    void setVar(int value) { privateVar = value; }

    friend void testPrivateVar(MyClass &obj);
};

void testPrivateVar(MyClass &obj) {
    assert(obj.privateVar == 10);
}

int main() {
    MyClass obj;
    obj.setVar(10);
    testPrivateVar(obj);
    return 0;
}

この例では、MyClassクラスのprivateVarをテストするために、testPrivateVarというフレンド関数を利用しています。この関数は、privateVarにアクセスしてその値を検証します。

テスト用のアクセサメソッド

別の方法として、テスト専用のアクセサメソッドをクラスに追加する方法があります。ただし、これは通常、プロダクションコードには含めないようにし、テストビルドでのみ利用することが推奨されます。

class MyClass {
private:
    int privateVar;

public:
    MyClass() : privateVar(0) {}

    void setVar(int value) { privateVar = value; }

#ifdef TEST_BUILD
    int getPrivateVar() const { return privateVar; }
#endif
};

void testPrivateVar() {
    MyClass obj;
    obj.setVar(10);
#ifdef TEST_BUILD
    assert(obj.getPrivateVar() == 10);
#endif
}

int main() {
    testPrivateVar();
    return 0;
}

privateメンバーの利点と欠点

  • 利点: クラスのカプセル化を強化し、外部からの不正アクセスを防止します。
  • 欠点: ユニットテストを行う際に、特別な手法や工夫が必要であり、テストコードが複雑になることがあります。

フレンド関数とユニットテスト

フレンド関数は、クラスのprivateおよびprotectedメンバーにアクセスすることを許可された関数やクラスのことです。ユニットテストにおいて、フレンド関数を利用することで、通常はアクセスできないメンバーをテストすることができます。

フレンド関数の宣言と使用

フレンド関数を利用することで、クラスの内部状態を直接テストすることができます。以下に、フレンド関数を用いてユニットテストを行う方法を示します。

#include <cassert>

class MyClass {
private:
    int privateVar;

public:
    MyClass() : privateVar(0) {}

    void setVar(int value) { privateVar = value; }

    friend void testPrivateVar(const MyClass& obj);
};

void testPrivateVar(const MyClass& obj) {
    assert(obj.privateVar == 10);
}

int main() {
    MyClass obj;
    obj.setVar(10);
    testPrivateVar(obj);
    return 0;
}

この例では、MyClassクラスのprivateVarにアクセスするフレンド関数testPrivateVarを定義しています。この関数は、privateVarの値をチェックするために使用されます。

フレンドクラスの利用

フレンドクラスを使用することで、テストクラスが対象クラスのprivateおよびprotectedメンバーにアクセスできるようになります。

#include <cassert>

class MyClass {
private:
    int privateVar;

public:
    MyClass() : privateVar(0) {}

    void setVar(int value) { privateVar = value; }

    friend class TestMyClass;
};

class TestMyClass {
public:
    void testPrivateVar(const MyClass& obj) {
        assert(obj.privateVar == 10);
    }
};

int main() {
    MyClass obj;
    obj.setVar(10);
    TestMyClass tester;
    tester.testPrivateVar(obj);
    return 0;
}

この例では、TestMyClassがMyClassのフレンドクラスとして宣言されています。これにより、TestMyClassはMyClassのprivateメンバーprivateVarにアクセスできます。

フレンド関数とフレンドクラスの利点と欠点

  • 利点: フレンド関数やフレンドクラスを利用することで、通常アクセスできないメンバーをテストできるため、クラスの内部状態を詳細に検証できます。
  • 欠点: フレンド関数やフレンドクラスを追加することで、クラスの設計が複雑になることがあり、カプセル化の原則が緩和される可能性があります。

テストのためのデザインパターン

ユニットテストを効果的に行うためには、テストしやすいコード設計が重要です。C++では、ユニットテストを容易にするためのいくつかのデザインパターンがあります。

依存性の注入（Dependency Injection）

依存性の注入は、オブジェクトの依存関係を外部から注入するデザインパターンです。これにより、依存関係をモックやスタブに置き換えてテストすることが容易になります。

class Database {
public:
    virtual void connect() = 0;
    virtual ~Database() = default;
};

class MySQLDatabase : public Database {
public:
    void connect() override {
        // MySQLへの接続処理
    }
};

class DataProcessor {
private:
    Database& db;

public:
    DataProcessor(Database& database) : db(database) {}

    void process() {
        db.connect();
        // データ処理ロジック
    }
};

class MockDatabase : public Database {
public:
    void connect() override {
        // モックの接続処理
    }
};

void testProcess() {
    MockDatabase mockDb;
    DataProcessor processor(mockDb);
    processor.process();
    // モックを使用したテストの検証
}

この例では、DataProcessorクラスがDatabaseインターフェースを使用して依存性の注入を受けます。MockDatabaseを使用することで、テスト環境での依存関係を容易にモック化できます。

ファクトリーパターン（Factory Pattern）

ファクトリーパターンは、オブジェクトの生成をカプセル化するデザインパターンです。これにより、テスト時に生成するオブジェクトを容易に置き換えることができます。

class Product {
public:
    virtual void use() = 0;
    virtual ~Product() = default;
};

class ConcreteProduct : public Product {
public:
    void use() override {
        // 実際のプロダクトの使用処理
    }
};

class Factory {
public:
    virtual Product* createProduct() = 0;
    virtual ~Factory() = default;
};

class ConcreteFactory : public Factory {
public:
    Product* createProduct() override {
        return new ConcreteProduct();
    }
};

class MockFactory : public Factory {
public:
    Product* createProduct() override {
        // モックのプロダクトを生成
        return new ConcreteProduct();
    }
};

void testProductCreation() {
    MockFactory mockFactory;
    Product* product = mockFactory.createProduct();
    product->use();
    // プロダクト使用のテスト検証
    delete product;
}

この例では、Factoryクラスを使用してオブジェクトの生成をカプセル化しています。テスト時にはMockFactoryを使用して、生成されるオブジェクトをモック化します。

デザインパターンの利点と欠点

  • 利点: テストしやすいコード設計が可能になり、依存関係のモック化やオブジェクト生成の管理が容易になります。
  • 欠点: パターンの適用により、コードが複雑化することがあり、設計の理解が必要です。

モックとスタブの利用

モックとスタブは、ユニットテストにおいて依存関係をシミュレートするための手法です。これにより、テスト対象のクラスが依存する外部リソースやコンポーネントの振る舞いを制御しやすくなります。

スタブの利用

スタブは、特定のテスト条件に対して決まった応答を返す簡単なオブジェクトです。主に、外部依存性を置き換えるために使用されます。

class Database {
public:
    virtual int fetchData() = 0;
    virtual ~Database() = default;
};

class StubDatabase : public Database {
public:
    int fetchData() override {
        return 42; // 固定のデータを返す
    }
};

void testWithStub() {
    StubDatabase stubDb;
    int data = stubDb.fetchData();
    assert(data == 42); // スタブの返すデータを検証
}

この例では、Databaseインターフェースを実装したStubDatabaseを使用して、fetchDataメソッドが固定のデータを返すようにしています。これにより、テストが外部データベースに依存せず、安定して実行できます。

モックの利用

モックは、期待される呼び出しや応答を記録および検証できるオブジェクトです。主に、関数の呼び出し順序や回数をテストするために使用されます。

#include <gmock/gmock.h>

class Database {
public:
    virtual void connect() = 0;
    virtual int fetchData() = 0;
    virtual ~Database() = default;
};

class MockDatabase : public Database {
public:
    MOCK_METHOD(void, connect, (), (override));
    MOCK_METHOD(int, fetchData, (), (override));
};

void testWithMock() {
    MockDatabase mockDb;
    EXPECT_CALL(mockDb, connect())
        .Times(1);
    EXPECT_CALL(mockDb, fetchData())
        .Times(1)
        .WillOnce(::testing::Return(42));

    mockDb.connect();
    int data = mockDb.fetchData();
    assert(data == 42);
}

この例では、Google Mockライブラリを使用して、Databaseインターフェースをモック化しています。connectメソッドが1回呼び出され、fetchDataメソッドが1回呼び出された後、42を返すことを期待しています。これにより、メソッドの呼び出し順序と結果を詳細に検証できます。

モックとスタブの利点と欠点

  • 利点: 外部依存性を排除し、テストの信頼性と再現性を向上させることができます。特にモックは、複雑な依存関係の振る舞いを詳細に検証できます。
  • 欠点: モックとスタブの作成と管理には追加の労力が必要であり、テストコードが複雑になることがあります。

実践例: C++のクラスとユニットテスト

ここでは、実際のC++クラスを使用したユニットテストの例を紹介します。具体的なクラスの設計から、テストケースの作成方法までをステップバイステップで説明します。

例: カルキュレータクラス

まず、シンプルなカルキュレータクラスを定義します。このクラスには基本的な算術演算を行うメソッドが含まれています。

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

    int subtract(int a, int b) {
        return a - b;
    }

    int multiply(int a, int b) {
        return a * b;
    }

    double divide(int a, int b) {
        if (b == 0) throw std::invalid_argument("Division by zero");
        return static_cast<double>(a) / b;
    }
};

テストケースの作成

次に、Google Testフレームワークを使用して、このクラスのユニットテストを作成します。Google Testは、C++のための広く使われているユニットテストフレームワークです。

#include <gtest/gtest.h>
#include "Calculator.h"

TEST(CalculatorTest, Addition) {
    Calculator calc;
    EXPECT_EQ(calc.add(3, 4), 7);
    EXPECT_EQ(calc.add(-1, 1), 0);
    EXPECT_EQ(calc.add(-1, -1), -2);
}

TEST(CalculatorTest, Subtraction) {
    Calculator calc;
    EXPECT_EQ(calc.subtract(10, 5), 5);
    EXPECT_EQ(calc.subtract(-1, 1), -2);
    EXPECT_EQ(calc.subtract(-1, -1), 0);
}

TEST(CalculatorTest, Multiplication) {
    Calculator calc;
    EXPECT_EQ(calc.multiply(3, 4), 12);
    EXPECT_EQ(calc.multiply(-1, 1), -1);
    EXPECT_EQ(calc.multiply(-1, -1), 1);
}

TEST(CalculatorTest, Division) {
    Calculator calc;
    EXPECT_EQ(calc.divide(10, 2), 5);
    EXPECT_THROW(calc.divide(1, 0), std::invalid_argument);
    EXPECT_NEAR(calc.divide(1, 3), 0.3333, 0.0001);
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

テストの実行

上記のテストケースをコンパイルして実行すると、各メソッドの動作が検証されます。Google Testは、テスト結果を詳細に報告し、失敗したテストケースについての情報も提供します。

g++ -std=c++11 -isystem /usr/local/include -pthread calculator_test.cpp -o calculator_test -lgtest -lgtest_main
./calculator_test

このコマンドを実行することで、テストが実行され、結果が表示されます。

実践例のまとめ

  • クラス定義: テスト対象のクラスを定義します。
  • テストケース作成: 各メソッドに対するテストケースをGoogle Testを使って作成します。
  • テストの実行: テストをコンパイルし、実行して結果を確認します。

これにより、実際のC++クラスに対するユニットテストの基本的な流れを理解できます。

まとめ

本記事では、C++のアクセス指定子（public, protected, private）とユニットテストの関係について詳しく解説しました。アクセス指定子ごとのユニットテストの方法や、それに伴う利点と欠点、そしてテストを容易にするためのデザインパターンやモック、スタブの利用方法を紹介しました。最後に、具体的なC++クラスを用いた実践例を通じて、ユニットテストの実装手順を説明しました。これらの知識を活用して、効率的で効果的なユニットテストを実施し、堅牢なC++プログラムを開発してください。

C++
プログラミング ユニットテスト オブジェクト指向 C++ アクセス指定子

コメント

コメントする

目次