In this challenge, you are asked to implement a function that demonstrates **exception translation**. Your goal is to catch a standard exception, such as `std::out_of_range`, and then throw a custom exception instead. This technique is useful for **abstraction**, allowing you to hide implementation details and provide a consistent interface for error handling in your code.


#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>


#include <vector>
#include <exception>

class IndexError : public std::exception {
public:
    const char* what() const noexcept override;
};

void translateException(std::vector<int>& vec, int index);

TEST_CASE("translateException does not throw for valid index", "[translateException]") {
    std::vector<int> v = {10, 20, 30};
    REQUIRE_NOTHROW(translateException(v, 2));
}

TEST_CASE("translateException throws IndexError for out-of-range index", "[translateException]") {
    std::vector<int> v = {10, 20, 30};
    try {
        translateException(v, 5);
        REQUIRE(false); // Should not reach here
    } catch(const IndexError& e) {
        REQUIRE(std::string(e.what()) == "Index out of range");
    } catch(...) {
        REQUIRE(false); // Should not throw other exceptions
    }
}

TEST_CASE("translateException does not throw for index 0", "[translateException]") {
    std::vector<int> v = {99};
    REQUIRE_NOTHROW(translateException(v, 0));
}

TEST_CASE("translateException throws IndexError for negative index (if applicable)", "[translateException]") {
    std::vector<int> v = {1, 2, 3};
    try {
        translateException(v, -1);
        REQUIRE(false); // Should not reach here
    } catch(const IndexError& e) {
        REQUIRE(std::string(e.what()) == "Index out of range");
    } catch(...) {
        REQUIRE(false); // Should not throw other exceptions
    }
}

TEST_CASE("translateException does not throw for last valid index", "[translateException]") {
    std::vector<int> v = {1, 2, 3, 4};
    REQUIRE_NOTHROW(translateException(v, 3));
}

test.cpp

A practical course on mastering exception handling in modern C++. Learn how to write robust code by detecting, throwing, and managing errors using exceptions. Each section introduces a new aspect of exception handling, followed by hands-on challenges inspired by real-world scenarios.

Understand the basics of exception handling in C++. Learn about try-catch blocks, throw statements, and the standard exception hierarchy.

Learn how to define and use your own exception classes for more descriptive error handling.

Discover how to write exception-safe code and manage resources properly using RAII.

Explore advanced techniques such as exception propagation, rethrowing, and exception specifications.

Challenge: Exception Translation

Oplossing

Awesome!

Challenge: Exception Translation

Oplossing