Password Generator

#pragma once
#include <string>

enum CharSet {
    CS_LOWER = 1,
    CS_UPPER = 2,
    CS_DIGITS = 4,
    CS_SYMBOLS = 8,
};

// Builds the pool of characters selected by `mask` (an OR of CharSet
// values). Returns the empty string if `mask` selects nothing.
std::string build_pool(int mask);

// Generates a random password of `length` characters drawn from the pool
// selected by `mask`, using `rng` as the source of randomness -- a
// template so the real program can pass a genuinely secure
// std::mt19937 seeded from std::random_device, while the tests pass a
// small seeded deterministic engine for reproducible output. Returns an
// empty string if the mask selects no characters or length is not
// positive.
template <typename RNG>
std::string generate_password(int length, int mask, RNG &rng);

#include "PasswordGenerator.tpp"

#pragma once
#include <random>

template <typename RNG>
std::string generate_password(int length, int mask, RNG &rng) {
    std::string pool = build_pool(mask);
    if (pool.empty() || length <= 0) return "";

    std::uniform_int_distribution<std::size_t> dist(0, pool.size() - 1);
    std::string out;
    out.reserve(static_cast<std::size_t>(length));
    for (int i = 0; i < length; i++) {
        out += pool[dist(rng)];
    }
    return out;
}

#include "PasswordGenerator.hpp"

std::string build_pool(int mask) {
    std::string pool;
    if (mask & CS_LOWER) pool += "abcdefghijklmnopqrstuvwxyz";
    if (mask & CS_UPPER) pool += "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if (mask & CS_DIGITS) pool += "0123456789";
    if (mask & CS_SYMBOLS) pool += "!@#$%^&*()-_=+";
    return pool; // empty if mask selected no character set at all
}

#include "PasswordGenerator.hpp"
#include <iostream>
#include <random>

int main(int argc, char **argv) {
    int length = argc > 1 ? std::stoi(argv[1]) : 16;
    int mask = CS_LOWER | CS_UPPER | CS_DIGITS | CS_SYMBOLS;

    // std::random_device is a real, non-deterministic entropy source on this
    // platform (confirmed by checking its .entropy() is non-zero), seeding a
    // std::mt19937 for the actual generation work. This is standard, portable
    // C++ -- no external library or platform-specific extension needed.
    std::random_device rd;
    std::mt19937 rng(rd());

    std::string password = generate_password(length, mask, rng);
    if (password.empty()) {
        std::cerr << "Could not generate a password (bad length or empty character set)\n";
        return 1;
    }
    std::cout << password << "\n";
    return 0;
}

#include "PasswordGenerator.hpp"
#include <cassert>
#include <iostream>
#include <random>

#define RUN(name) do { name(); std::cout << "PASS: " << #name << "\n"; } while (0)

static void build_pool_includes_only_selected_sets() {
    assert(build_pool(CS_LOWER) == "abcdefghijklmnopqrstuvwxyz");
    assert(build_pool(CS_DIGITS) == "0123456789");
    std::string both = build_pool(CS_LOWER | CS_DIGITS);
    assert(both.find("a") != std::string::npos);
    assert(both.find("5") != std::string::npos);
    assert(both.find("A") == std::string::npos);
}

static void an_empty_selection_builds_an_empty_pool() {
    assert(build_pool(0).empty());
}

static void generated_password_has_the_requested_length() {
    std::mt19937 rng(42); // fixed seed -- deterministic and reproducible for a test
    std::string pw = generate_password(12, CS_LOWER | CS_DIGITS, rng);
    assert(pw.size() == 12);
}

static void every_character_comes_from_the_selected_pool() {
    std::mt19937 rng(7);
    std::string pool = build_pool(CS_UPPER | CS_SYMBOLS);
    std::string pw = generate_password(50, CS_UPPER | CS_SYMBOLS, rng);
    for (char ch : pw) {
        assert(pool.find(ch) != std::string::npos);
    }
}

static void an_empty_character_set_fails_cleanly_instead_of_crashing() {
    std::mt19937 rng(1);
    std::string pw = generate_password(10, 0, rng);
    assert(pw.empty()); // no character set selected -> no password, not garbage
}

static void a_non_positive_length_produces_an_empty_string() {
    std::mt19937 rng(1);
    assert(generate_password(0, CS_LOWER, rng).empty());
    assert(generate_password(-5, CS_LOWER, rng).empty());
}

int main() {
    RUN(build_pool_includes_only_selected_sets);
    RUN(an_empty_selection_builds_an_empty_pool);
    RUN(generated_password_has_the_requested_length);
    RUN(every_character_comes_from_the_selected_pool);
    RUN(an_empty_character_set_fails_cleanly_instead_of_crashing);
    RUN(a_non_positive_length_produces_an_empty_string);
    std::cout << "All tests passed.\n";
    return 0;
}

$ ./genpw 20
#=cWX((6d@tfpK_YeG!P

// Jenkinsfile — compiles, tests, and checks for leaks on every change.
pipeline {
    agent any

    stages {
        stage('Get the code') {
            // download the latest code
            steps { checkout scm }
        }
        stage('Compile') {
            steps {
                // confirm a compiler is installed
                sh 'g++ --version'
                // compile with strict warnings on
                sh 'g++ -std=c++20 -Wall -Wextra -o app *.cpp'
            }
        }
        stage('Run the tests') {
            steps {
                // prints PASS/FAIL, exits non-zero on failure
                sh './app'
            }
        }
        stage('Check for memory leaks') {
            steps {
                // fails the build on any leak or invalid access
                sh 'valgrind --error-exitcode=1 --leak-check=full ./app'
            }
        }
    }

    post {
        success { echo 'All tests passed, no leaks found.' }
        failure { echo 'A test or Valgrind check failed — see above.' }
    }
}