Bagian 4: Error Handling dan Testing

<?php

declare(strict_types=1);

/**
 * Kalkulator Terminal — Bagian 4: Error Handling dan Testing (versi final).
 *
 * Pemakaian:
 *   php main.php hitung <angka1> <operator> <angka2>
 *   php main.php versi
 *
 * Dipanggil tanpa argumen, program mencetak panduan pemakaian lalu
 * keluar dengan exit code 0.
 *
 * Berkas ini aman untuk di-require dari test: eksekusi program utama
 * hanya terjadi ketika berkas ini dijalankan langsung lewat `php main.php`.
 */

const APP_NAME = 'Kalkulator Terminal';
const APP_VERSION = '1.0.0';

/** Daftar operator yang dikenali oleh perintah hitung. */
const KNOWN_OPERATORS = ['+', '-', '*', '/', '%', '**', 'intdiv'];

/** Cetak panduan pemakaian program ke STDOUT. */
function printUsage(): void
{
    echo "Pemakaian:\n";
    echo "  php main.php hitung <angka1> <operator> <angka2>\n";
    echo "  php main.php versi\n";
    echo "\n";
    echo "Operasi yang didukung:\n";
    echo '  ' . implode('  ', KNOWN_OPERATORS) . "\n";
}

/** Tangani perintah `versi`: cetak nama dan versi program. */
function commandVersi(): int
{
    echo APP_NAME . ' versi ' . APP_VERSION . "\n";

    return 0;
}

/**
 * Ubah string argumen menjadi angka int atau float.
 *
 * Bentuk bilangan bulat ("5", "-3", "+7") dikonversi ke int; bentuk
 * lain yang lolos pemeriksaan is_numeric() ("7.5", "1e3") dikonversi
 * ke float supaya bagian pecahannya tidak hilang.
 */
function toNumber(string $value): int|float
{
    if (isIntegerLiteral($value)) {
        return (int) $value;
    }

    return (float) $value;
}

/** Apakah string ini bentuk harfiah bilangan bulat, mis. "5" atau "-3"? */
function isIntegerLiteral(string $value): bool
{
    return preg_match('/^[+-]?\d+$/', $value) === 1;
}

/**
 * Validasi isi tiga argumen perintah hitung.
 *
 * Mengembalikan string pesan error bila ada masalah, atau null bila
 * seluruh argumen lolos validasi.
 */
function validateOperands(array $args): ?string
{
    [$aRaw, $operator, $bRaw] = $args;

    foreach ([$aRaw, $bRaw] as $operand) {
        if (!is_numeric($operand)) {
            return "Error: '{$operand}' bukan angka yang valid.";
        }
    }

    if (!in_array($operator, KNOWN_OPERATORS, true)) {
        return "Error: operator tidak dikenal: '{$operator}'. "
            . 'Operator yang didukung: ' . implode(' ', KNOWN_OPERATORS) . '.';
    }

    if ($operator === '%' || $operator === 'intdiv') {
        foreach ([$aRaw, $bRaw] as $operand) {
            if (!isIntegerLiteral($operand)) {
                return "Error: operator '{$operator}' hanya menerima bilangan bulat, "
                    . "diberikan '{$operand}'.";
            }
        }
    }

    return null;
}

/**
 * Hitung satu operasi aritmatika dan kembalikan hasilnya.
 *
 * Kontrak fungsi murni ini:
 * - operator yang dikenali (+ - * / % ** intdiv) mengembalikan hasil
 *   berupa int atau float;
 * - pembagian, modulo, atau intdiv dengan nol melempar DivisionByZeroError;
 * - operator di luar daftar melempar InvalidArgumentException sebagai
 *   pertahanan terakhir, meskipun validasi CLI seharusnya sudah menyaringnya.
 */
function hitung(int|float $a, string $operator, int|float $b): int|float
{
    return match ($operator) {
        '+' => $a + $b,
        '-' => $a - $b,
        '*' => $a * $b,
        '/' => $a / $b,
        '%' => $a % $b,
        '**' => $a ** $b,
        'intdiv' => intdiv($a, $b),
        default => throw new InvalidArgumentException(
            "Operator tidak dikenal: '{$operator}'"
        ),
    };
}

/** Tangani perintah `hitung <angka1> <operator> <angka2>`. */
function commandHitung(array $args): int
{
    // Gerbang pertama: bentuk panggilan (jumlah argumen).
    if (count($args) !== 3) {
        fwrite(STDERR, "Error: perintah hitung membutuhkan tepat 3 argumen "
            . '(angka1 operator angka2), diberikan ' . count($args) . ".\n\n");
        printUsage();

        return 1;
    }

    // Gerbang kedua: isi setiap argumen.
    $error = validateOperands($args);
    if ($error !== null) {
        fwrite(STDERR, $error . "\n");

        return 1;
    }

    [$aRaw, $operator, $bRaw] = $args;

    try {
        $hasil = hitung(toNumber($aRaw), $operator, toNumber($bRaw));
    } catch (DivisionByZeroError $e) {
        fwrite(STDERR, "Error: pembagian dengan nol tidak diperbolehkan.\n");

        return 1;
    }

    echo $hasil . "\n";

    return 0;
}

/** Laporkan perintah yang tidak dikenal, lalu cetak panduan pemakaian. */
function unknownCommand(string $command): int
{
    fwrite(STDERR, "Error: perintah tidak dikenal: {$command}\n");
    printUsage();

    return 1;
}

/**
 * Titik masuk program: terima $argv, tentukan perintah yang diminta,
 * dan kembalikan exit code ke pemanggil.
 */
function main(array $argv): int
{
    // Buang nama skrip (elemen pertama) — sisanya adalah argumen pengguna.
    $args = array_slice($argv, 1);

    // Tanpa argumen: pengguna hanya butuh tahu cara memakai program.
    if ($args === []) {
        printUsage();

        return 0;
    }

    $command = $args[0];
    $commandArgs = array_slice($args, 1);

    return match ($command) {
        'versi' => commandVersi(),
        'hitung' => commandHitung($commandArgs),
        default => unknownCommand($command),
    };
}

// Jalankan program hanya bila berkas ini dieksekusi langsung
// (php main.php ...), bukan saat di-require dari berkas test lain.
if (isset($argv) && realpath($argv[0]) === realpath(__FILE__)) {
    exit(main($argv));
}

<?php

declare(strict_types=1);

use PHPUnit\Framework\TestCase;

require __DIR__ . '/../main.php';

final class CalculatorTest extends TestCase
{
    public function testPenjumlahanMengembalikanBilanganBulat(): void
    {
        self::assertSame(12, hitung(7, '+', 5));
    }

    public function testPengurangan(): void
    {
        self::assertSame(3, hitung(10, '-', 7));
    }

    public function testPerkalian(): void
    {
        self::assertSame(150000, hitung(500, '*', 300));
    }

    public function testPembagianYangHabisDibagiMengembalikanBilanganBulat(): void
    {
        self::assertSame(2, hitung(10, '/', 5));
    }

    public function testPembagianTidakHabisMengembalikanPecahan(): void
    {
        self::assertSame(3.5, hitung(7, '/', 2));
    }

    public function testModulo(): void
    {
        self::assertSame(1, hitung(7, '%', 3));
    }

    public function testIntdivMembulatkanKeArahNol(): void
    {
        self::assertSame(-3, hitung(-7, 'intdiv', 2));
    }

    public function testPangkat(): void
    {
        self::assertSame(1024, hitung(2, '**', 10));
    }

    public function testPembagianDenganNolMelemparDivisionByZeroError(): void
    {
        $this->expectException(DivisionByZeroError::class);

        hitung(10, '/', 0);
    }

    public function testModuloDenganNolMelemparDivisionByZeroError(): void
    {
        $this->expectException(DivisionByZeroError::class);

        hitung(10, '%', 0);
    }

    public function testIntdivDenganNolMelemparDivisionByZeroError(): void
    {
        $this->expectException(DivisionByZeroError::class);

        hitung(10, 'intdiv', 0);
    }

    public function testOperatorTidakDikenalMelemparInvalidArgumentException(): void
    {
        $this->expectException(InvalidArgumentException::class);

        hitung(5, 'pangkat', 2);
    }
}