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

// Function under test
int sum_elements(const std::list<int>& numbers);

// Basic correctness tests
TEST_CASE("Sum of {1, 2, 3, 4, 5} is 15", "[sum_elements]") {
    std::list<int> nums = {1, 2, 3, 4, 5};
    REQUIRE(sum_elements(nums) == 15);
}

TEST_CASE("Sum of empty list is 0", "[sum_elements]") {
    std::list<int> nums;
    REQUIRE(sum_elements(nums) == 0);
}

TEST_CASE("Sum of single-element list {42} is 42", "[sum_elements]") {
    std::list<int> nums = {42};
    REQUIRE(sum_elements(nums) == 42);
}

TEST_CASE("Sum of negative numbers {-5, -10, -15} is -30", "[sum_elements]") {
    std::list<int> nums = {-5, -10, -15};
    REQUIRE(sum_elements(nums) == -30);
}

TEST_CASE("Sum of mixed numbers {10, -5, 0, 7} is 12", "[sum_elements]") {
    std::list<int> nums = {10, -5, 0, 7};
    REQUIRE(sum_elements(nums) == 12);
}

// Traversal-specific safety tests

TEST_CASE("Traversal must handle empty container safely", "[sum_elements][traversal]") {
    std::list<int> nums;
    // Fails if implementation tries to dereference begin() when begin() == end()
    REQUIRE_NOTHROW(sum_elements(nums));
    REQUIRE(sum_elements(nums) == 0);
}

TEST_CASE("Traversal must not dereference end()", "[sum_elements][traversal]") {
    std::list<int> nums = {1};
    // Incorrect loops that dereference end() often crash or miscount here
    REQUIRE(sum_elements(nums) == 1);
}

TEST_CASE("Traversal must visit all elements exactly once", "[sum_elements][traversal]") {
    std::list<int> nums = {1, 1, 1, 1};
    // Detects early termination or skipping ++it
    REQUIRE(sum_elements(nums) == 4);
}

TEST_CASE("Traversal must work regardless of list layout", "[sum_elements][traversal]") {
    std::list<int> nums;
    for (int i = 0; i < 100; ++i) {
        nums.push_back(1);
    }
    // Ensures correct begin() → end() traversal over many nodes
    REQUIRE(sum_elements(nums) == 100);
}

test.cpp

This course explains how iterators work in the C++ Standard Template Library and how they connect containers and algorithms. You will learn what iterators are, how different iterator categories behave, and how to use them safely and idiomatically with STL containers and algorithms. By the end of the course, you will confidently read, write, and reason about iterator-based code, including const iterators, reverse iterators, and iterator invalidation rules.

Learn the foundational concepts of iterators, their purpose in the STL, and how to use them for basic container traversal.

Delve into the different categories of iterators, their capabilities, and which containers support each category.

Investigate how iterators behave with different STL containers, including sequence and associative containers, and the importance of const iterators.

Learn how STL algorithms interact with iterators, how to use them safely, and how to avoid iterator invalidation.

Challenge: Traverse and Sum Elements

Ratkaisu