Tests.cpp

[詳解]

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   Tests.cpp                                          :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: kamitsui <kamitsui@student.42tokyo.jp>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/06/03 20:25:55 by kamitsui          #+#    #+#             */
/*   Updated: 2025/06/03 20:26:42 by kamitsui         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#include "Tests.hpp"
#include "Animal.hpp"
#include "Cat.hpp"
#include "Dog.hpp"
#include "ScopedPointer.hpp" // 自作したスマートポインタ
#include "WrongAnimal.hpp"
#include "WrongCat.hpp"
#include <cstdlib> // EXIT_FAILURE のために必要
#include <iostream>
 
int wrongPolymorphism(void) {
    std::cout << "\n--- Wrong Polymorphism ---" << std::endl;
 
    // ScopedPointer を使用してリソースを自動管理
    // new が失敗した場合でも、ScopedPointer のデストラクタが呼ばれる
    // 割り当て失敗時のエラーハンドリングも Try-Catch で捕捉できる
    ScopedPointer<WrongAnimal> wrongMeta;
    ScopedPointer<WrongAnimal> wrongJ;
 
    try {
        wrongMeta.reset(new WrongAnimal()); // new に失敗したら std::bad_alloc をスロー
        wrongJ.reset(new WrongCat());       // new に失敗したら std::bad_alloc をスロー
 
        // get() を使って生ポインタを取得し、null チェックする (防御的プログラミング)
        if (wrongJ.get()) {
            std::cout << wrongJ->getType() << " " << std::endl;
        }
        if (wrongJ.get()) {
            wrongJ->makeSound(); // "Wrong generic animal sound"
        }
        if (wrongMeta.get()) {
            std::cout << wrongMeta->getType() << " " << std::endl;
        }
        if (wrongMeta.get()) {
            wrongMeta->makeSound(); // "Wrong generic animal sound"
        }
 
        // 明示的な delete は不要。ScopedPointer のデストラクタがスコープを抜けるときに呼ばれる。
 
    } catch (const std::bad_alloc &e) {
        // メモリ割り当て失敗の例外を捕捉
        std::cerr << "Error: Memory allocation failed in wrongPolymorphism! " << e.what() << std::endl;
        // 例外捕捉後、ScopedPointer のデストラクタが自動で呼ばれ、
        // 既に割り当てたメモリは解放されることが保証される。
        // ここで return すると、関数を抜ける際にスタック上のScopedPointerもデストロイされる。
        return EXIT_FAILURE; // 関数を異常終了させる
    } catch (const std::exception &e) {
        // その他の標準例外を捕捉
        std::cerr << "An unexpected standard error occurred in wrongPolymorphism: " << e.what() << std::endl;
        return EXIT_FAILURE;
    } catch (...) {
        // 捕捉しきれない例外を捕捉
        std::cerr << "An unknown error occurred in wrongPolymorphism." << std::endl;
        return EXIT_FAILURE;
    }
 
    // 関数終了時に wrongMeta と wrongJ の ScopedPointer デストラクタが呼ばれ、
    // それらが管理していたメモリが自動的に解放される。
 
    std::cout << "--- Wrong Polymorphism finished ---" << std::endl;
    std::cout << std::endl;
    return 0;
}
 
void animalRegularTests(void) {
    std::cout << "\n--- Animal Regular Tests ---" << std::endl;
 
    // Test objects created on the stack to see constructor/destructor calls
    Animal basicAnimal;
    Dog basicDog;
    Cat basicCat;
 
    // Call getType() and makeSound() on stack objects
    std::cout << basicAnimal.getType() << " " << std::endl;
    std::cout << basicDog.getType() << " " << std::endl;
    std::cout << basicCat.getType() << " " << std::endl;
    basicAnimal.makeSound();
    basicDog.makeSound();
    basicCat.makeSound();
 
    std::cout << std::endl;
}
 
int animalArraySounds(void) {
    std::cout << "\n--- Animal Array Sounds ---" << std::endl;
 
    // Test polymorphic array
    ScopedPointer<Animal> animalArray[4]; // ScopedPointer array
    try {
        animalArray[0].reset(new Dog()); // newが失敗しても、既に確保されたものはRAIIで解放
        animalArray[1].reset(new Cat());
        animalArray[2].reset(new Dog());
        animalArray[3].reset(new Cat());
 
        for (int k = 0; k < 4; ++k) {
            // nullチェックは必要 (new が失敗した場合) : Defensive Programming 防御的プログラミング
            if (animalArray[k].get()) {
                std::cout << animalArray[k]->getType() << " says: ";
                animalArray[k]->makeSound();
            }
        }
    } catch (const std::bad_alloc &e) {
        std::cerr << "Error: Memory allocation failed in array! " << e.what() << std::endl;
        // 例外を捕捉後、配列内のScropePointerデストラクタが呼ばれ、
        // 既に割り当てたメモリが解放されることが保証される。
        // ここで return すると、関数を抜ける際に残りのanimalArray要素も解放される。
        return EXIT_FAILURE;
    }
    std::cout << std::endl;
    return 0;
}
 
void animalCopyConstAndAssignment(void) {
    std::cout << "\n--- Copy Constructor and Assignment (Regular) ---" << std::endl;
    Dog anotherDog;
    Dog yetAnotherDog(anotherDog); // Copy constructor
    Cat anotherCat;
    Cat yetAnotherCat;
    yetAnotherCat = anotherCat; // Copy assignment operator
 
    std::cout << anotherDog.getType() << " copied to " << yetAnotherDog.getType() << std::endl;
    std::cout << anotherCat.getType() << " assigned to " << yetAnotherCat.getType() << std::endl;
 
    std::cout << std::endl;
}
 
void wrongAnimalRegularTests(void) {
    std::cout << "\n--- More Tests (Wrong) ---" << std::endl;
    // Test wrong objects on the stack
    WrongAnimal basicWrongAnimal;
    WrongCat basicWrongCat;
 
    std::cout << basicWrongAnimal.getType() << " " << std::endl;
    std::cout << basicWrongCat.getType() << " " << std::endl;
    basicWrongAnimal.makeSound();
    basicWrongCat.makeSound();
 
    std::cout << std::endl;
}
 
int wrongAnimalArraySounds(void) {
    std::cout << "\n--- Wrong Animal Array Sounds ---" << std::endl;
 
    // Use ScopedPointer array for RAII
    // If 'new WrongCat()' fails partway through, the ScopedPointers
    // already created will automatically free their resources.
    ScopedPointer<WrongAnimal> wrongAnimalArray[2];
 
    try {
        wrongAnimalArray[0].reset(new WrongCat());
        wrongAnimalArray[1].reset(new WrongCat()); // If this fails, wrongAnimalArray[0] is still cleaned up
 
        // --- Demonstrate makeSound() behavior (NO polymorphic dispatch for WrongCat) ---
        for (int l = 0; l < 2; ++l) {
            // Defensive null check:
            // Though new should throw std::bad_alloc, this ensures safety
            // if a pointer somehow became null (e.g., new(std::nothrow) was used)
            if (wrongAnimalArray[l].get()) {
                std::cout << wrongAnimalArray[l]->getType() << " says: ";
                wrongAnimalArray[l]->makeSound(); // Will output WrongAnimal sound (static binding)
            } else {
                std::cerr << "Array element is null, skipping makeSound() call." << std::endl;
            }
        }
 
        // Explicit 'delete' calls are no longer needed.
        // ScopedPointer's destructors handle deallocation when they go out of scope.
 
    } catch (const std::bad_alloc &e) {
        // Catch block handles memory allocation failures
        std::cerr << "Error: Memory allocation failed in wrongAnimalArraySounds! " << e.what() << std::endl;
        // The ScopedPointer destructors for successfully allocated objects
        // will be called automatically as they go out of scope.
        return EXIT_FAILURE; // Exit the function gracefully upon failure
    } catch (const std::exception &e) {
        // Catch other standard exceptions
        std::cerr << "An unexpected standard error occurred in wrongAnimalArraySounds: " << e.what() << std::endl;
        return EXIT_FAILURE;
    } catch (...) {
        // Catch any other unknown exceptions
        std::cerr << "An unknown error occurred in wrongAnimalArraySounds." << std::endl;
        return EXIT_FAILURE;
    }
 
    // When the function ends, 'wrongAnimalArray' (which contains ScopedPointer objects)
    // goes out of scope. Each ScopedPointer's destructor is called,
    // ensuring the dynamically allocated 'WrongAnimal' objects are deleted.
    std::cout << "--- Wrong Animal Array Sounds finished ---" << std::endl;
 
    // Test wrong polymorphic array
    // WrongAnimal *wrongAnimalArray[2];
    // wrongAnimalArray[0] = new WrongCat();
    // wrongAnimalArray[1] = new WrongCat();
 
    // std::cout << "--- Wrong Animal Array Sounds ---" << std::endl;
    // for (int l = 0; l < 2; ++l) {
    //     std::cout << wrongAnimalArray[l]->getType() << " says: ";
    //     wrongAnimalArray[l]->makeSound(); // Will output WrongAnimal sound (static binding)
    // }
 
    // for (int l = 0; l < 2; ++l) {
    //     delete wrongAnimalArray[l];
    // }
 
    // std::cout << std::endl;
    return 0;
}
 
void wrongAnimalCopyConstAndAssignment(void) {
    std::cout << "\n--- Copy Constructor and Assignment (Wrong) ---" << std::endl;
    WrongCat anotherWrongCat;
    // Copy constructor
    WrongCat yetAnotherWrongCat(anotherWrongCat);
    WrongAnimal yetAnotherWrongAnimal;
    // Note: Assignment of WrongCat to WrongAnimal (slicing might occur if not careful with ownership)
    yetAnotherWrongAnimal = anotherWrongCat;
 
    std::cout << anotherWrongCat.getType() << " copied to " << yetAnotherWrongCat.getType() << std::endl;
    std::cout << yetAnotherWrongCat.getType() << " assigned to " << yetAnotherWrongAnimal.getType() << std::endl;
    // Will output WrongAnimal sound due to static binding on WrongAnimal object
    yetAnotherWrongAnimal.makeSound();
 
    std::cout << std::endl;
}