chapter_11/chapter-11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "08c06ffc-8d7a-42e3-97cb-37fb1018901a",
   "metadata": {},
   "source": [
    "# Google Colab Rust Setup\n",
    "\n",
    "The following cell is used to set up and spin up a Jupyter Notebook environment with a Rust kernel using Nix and IPC Proxy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4608fcd6-71e2-4d25-8551-864d322e3fd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget -qO- https://gist.github.com/wiseaidev/2af6bef753d48565d11bcd478728c979/archive/3f6df40db09f3517ade41997b541b81f0976c12e.tar.gz | tar xvz --strip-components=1\n",
    "!bash setup_evcxr_kernel.sh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60c8d72c-b011-4360-b368-d540b8d7361a",
   "metadata": {},
   "source": [
    "## Unit Testing in Rust"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38339871-7f3d-49d8-9b4f-e77f9e2a88da",
   "metadata": {},
   "source": [
    "### Writing a Basic Test Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e93816e8-c065-4dad-84dc-861b6746fd52",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::process::{Command, Output, Stdio};\n",
    "\n",
    "// A helper function to execute a shell command from a Rust script\n",
    "fn execute_command(command: &str) -> Result<(), std::io::Error> {\n",
    "    let status = Command::new(\"bash\")\n",
    "        .arg(\"-c\")\n",
    "        .arg(command)\n",
    "        .stderr(Stdio::inherit())\n",
    "        .status()?;\n",
    "\n",
    "    if status.success() {\n",
    "        Ok(())\n",
    "    } else {\n",
    "        Err(std::io::Error::from_raw_os_error(status.code().unwrap_or(1)))\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a163999f-7353-4fb9-88cf-61ac934c34f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[test]\n",
    "fn test_complex_addition() {\n",
    "    let input_1 = 42;\n",
    "    let input_2 = 58;\n",
    "\n",
    "    let result = perform_complex_addition(input_1, input_2);\n",
    "\n",
    "    assert_eq!(result, 100, \"The addition result is incorrect.\");\n",
    "}\n",
    "\n",
    "fn perform_complex_addition(a: i32, b: i32) -> i32 {\n",
    "    a + b\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9ea5800e-7797-43c0-b708-a826cbe4c626",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/basic_test_function-ab5a076178427322)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test test_complex_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd 1-basic-test-function && cargo test\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc79a518-7d60-4770-a7f0-be4dad4863d0",
   "metadata": {},
   "source": [
    "### Test Modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92d1294c-4c45-4fb3-83ca-04f66acaaa4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "mod mod_tests {\n",
    "    #[test]\n",
    "    fn test_addition() {\n",
    "        let input_1 = 42;\n",
    "        let input_2 = 58;\n",
    "\n",
    "        let result = perform_addition(input_1, input_2);\n",
    "\n",
    "        assert_eq!(result, 100, \"The addition result is incorrect.\");\n",
    "    }\n",
    "\n",
    "    fn perform_addition(a: i32, b: i32) -> i32 {\n",
    "        a + b\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "68f936fc-e249-414d-b3fd-b587c94ac052",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.01s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd 2-test-modules && cargo test\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d99dcda9-2498-4201-8605-363192355d8b",
   "metadata": {},
   "source": [
    "### Running Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "00407f55-cbc6-41a0-a18c-a8b5e0ae765d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test\n",
    "let command = \"cd 2-test-modules && cargo test\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "55f0841b-33b1-4273-8f9a-f4c9f886bbb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.01s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test test_addition\n",
    "let command = \"cd 2-test-modules && cargo test test_addition\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d9faaeda-4d44-40a6-824f-da88156641d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.01s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test mod_tests::test_addition -- --exact\n",
    "let command = \"cd 2-test-modules && cargo test mod_tests::test_addition -- --exact\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8976e380-17b1-45dc-b4bb-a36586f1ab95",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.01s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test --package test-modules mod_tests::test_addition -- --exact\n",
    "let command = \"cd 2-test-modules && cargo test --package test-modules mod_tests::test_addition -- --exact\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90418db7-9c84-4984-9322-5324f0d86abc",
   "metadata": {},
   "source": [
    "### Assertions in Rust"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d468a745-c1d0-4ec4-b94a-ed56404f05c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[test]\n",
    "fn test_assertions() {\n",
    "    assert_eq!(add(2, 2), 4);\n",
    "\n",
    "    assert_ne!(subtract(5, 2), 5);\n",
    "\n",
    "    assert!(is_even(4));\n",
    "\n",
    "    assert!(!is_odd(6));\n",
    "}\n",
    "\n",
    "fn add(a: i32, b: i32) -> i32 {\n",
    "    a + b\n",
    "}\n",
    "\n",
    "fn subtract(a: i32, b: i32) -> i32 {\n",
    "    a - b\n",
    "}\n",
    "\n",
    "fn is_even(n: i32) -> bool {\n",
    "    n % 2 == 0\n",
    "}\n",
    "\n",
    "fn is_odd(n: i32) -> bool {\n",
    "    n % 2 != 0\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9643740-ca4c-4984-8c6f-571db635ca6c",
   "metadata": {},
   "source": [
    "### Custom Error Messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "88ec91cb-c2eb-4b71-b596-b8931dde2f2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "assert_eq!(add(2, 2), 4, \"The addition result is incorrect.\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e596e439-2a70-4e8c-bc1f-33c3c7d8f999",
   "metadata": {},
   "source": [
    "### Running Tests with Options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "e6df82ac-6d82-45c2-8119-db7a5d8b5c18",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test -- --test-threads=1\n",
    "let command = \"cd 2-test-modules && cargo test -- --test-threads=1\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9aa24a62-6a5d-4355-8810-a41888d4d598",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished release [optimized] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/release/deps/test_modules-29e1e78e18e11e3b)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test --release\n",
    "let command = \"cd 2-test-modules && cargo test --release\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "882fa523-bcda-4be9-9665-ee0728a13050",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 0 tests\n",
      "\n",
      "test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test -- --ignored\n",
    "let command = \"cd 2-test-modules && cargo test -- --ignored\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f94ab4f4-288b-4fc5-be24-c92f5a863eb0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      ".\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test -- --quiet\n",
    "let command = \"cd 2-test-modules && cargo test -- --quiet\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "aa5b7663-7b28-4690-a534-cd9b8981dd0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test -- --nocapture\n",
    "let command = \"cd 2-test-modules && cargo test -- --nocapture\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "a4c55d70-a0d9-4c57-9690-275c8cd6a8dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Finished test [unoptimized + debuginfo] target(s) in 0.00s\n",
      "     Running unittests src/main.rs (target/debug/deps/test_modules-98d96e58e1f003c0)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "running 1 test\n",
      "test mod_tests::test_addition ... \u001b[32mok\u001b(B\u001b[m\n",
      "\n",
      "test result: \u001b[32mok\u001b(B\u001b[m. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "// cargo test -- --color=always\n",
    "let command = \"cd 2-test-modules && cargo test -- --color=always\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9363404e-f521-4b65-92b8-6222817bdce0",
   "metadata": {},
   "source": [
    "### Fixtures and Setup Code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b159c49c-db99-4203-873d-36476a70c022",
   "metadata": {},
   "outputs": [],
   "source": [
    "use std::collections::HashMap;\n",
    "\n",
    "fn create_fixture() -> HashMap<String, i32> {\n",
    "    let mut fixture = HashMap::new();\n",
    "    fixture.insert(\"foo\".to_string(), 42);\n",
    "    fixture.insert(\"bar\".to_string(), 37);\n",
    "    fixture\n",
    "}\n",
    "\n",
    "#[test]\n",
    "fn test_contains_foo() {\n",
    "    let fixture = create_fixture();\n",
    "    assert!(fixture.contains_key(\"foo\"));\n",
    "}\n",
    "\n",
    "#[test]\n",
    "fn test_contains_bar() {\n",
    "    let fixture = create_fixture();\n",
    "    assert!(fixture.contains_key(\"bar\"));\n",
    "}\n",
    "\n",
    "#[test]\n",
    "fn test_contains_baz() {\n",
    "    let fixture = create_fixture();\n",
    "    assert!(!fixture.contains_key(\"baz\"));\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f02b9abc-a1a2-4dc0-be87-d7c4101d560e",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep rstest = {version=\"0.18.2\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8777d797-377c-42b8-89c9-e309361f665b",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep tempfile = {version=\"3.8.0\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2ee16714-a48a-4821-95ac-9d39519c1548",
   "metadata": {},
   "outputs": [],
   "source": [
    "use rstest::{rstest, fixture};\n",
    "use std::fs;\n",
    "use tempfile::TempDir;\n",
    "\n",
    "#[fixture]\n",
    "fn temp_dir() -> TempDir {\n",
    "    TempDir::new().expect(\"Failed to create temporary directory\")\n",
    "}\n",
    "\n",
    "#[rstest]\n",
    "fn test_with_temp_dir(temp_dir: TempDir) {\n",
    "    let file_path = temp_dir.path().join(\"example.txt\");\n",
    "    fs::write(&file_path, \"Test data\").expect(\"Failed to write to the file\");\n",
    "\n",
    "    assert!(file_path.exists());\n",
    "    assert_eq!(fs::read_to_string(&file_path).expect(\"Failed to read file\"), \"Test data\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bd1d007f-4db9-4741-a3b1-df11b45fccb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn setup() -> String {\n",
    "    let resource = \"Some resource\".to_string();\n",
    "    println!(\"Setting up: {}\", resource);\n",
    "    resource\n",
    "}\n",
    "\n",
    "fn teardown(resource: String) {\n",
    "    println!(\"Tearing down: {}\", resource);\n",
    "}\n",
    "\n",
    "#[test]\n",
    "fn test_with_setup_and_teardown() {\n",
    "    let resource = setup();\n",
    "\n",
    "    let result = format!(\"Test using: {}\", resource);\n",
    "\n",
    "    assert_eq!(result, \"Test using: Some resource\");\n",
    "\n",
    "    teardown(resource);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67134989-b62a-4b60-8030-2a7e0b642ea6",
   "metadata": {},
   "source": [
    "### Conditional Tests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "2f2302d8-b82d-4562-b1e0-b1016fa81903",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[cfg(test)]\n",
    "mod tests {\n",
    "    #[test]\n",
    "    fn test_feature_enabled() {\n",
    "        assert_eq!(1 + 1, 2);\n",
    "    }\n",
    "\n",
    "    #[test]\n",
    "    fn test_feature_disabled() {\n",
    "        assert_eq!(2 * 3, 6);\n",
    "    }\n",
    "}\n",
    "\n",
    "#[cfg(not(test))]\n",
    "fn main() {\n",
    "    println!(\"This code is not included in test builds.\");\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "322da93a-f1ee-4fa1-845d-c2287fb3845c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[cfg(all(test, feature = \"my_feature\"))]\n",
    "mod tests {\n",
    "    #[test]\n",
    "    fn test_feature_enabled() {\n",
    "        assert_eq!(1 + 1, 2);\n",
    "    }\n",
    "\n",
    "    #[test]\n",
    "    fn test_feature_disabled() {\n",
    "        assert_eq!(2 * 3, 6);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "909d2329-049e-49b2-a341-b9d39350f3d5",
   "metadata": {},
   "source": [
    "### Asynchronous Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "18e3a8a8-47a7-4438-abf7-5d435633134b",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep tokio = { version = \"1.35.0\", features = [\"full\"] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7cb385e7-dc53-4f32-ab6f-cf112aac8193",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[tokio::test]\n",
    "async fn test_async_function() {\n",
    "    let result = async_function().await;\n",
    "    assert_eq!(result, 42);\n",
    "}\n",
    "\n",
    "async fn async_function() -> i32 {\n",
    "    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;\n",
    "    42\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "afb6655e-c4da-4787-a281-ae1ac2947cb9",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep async-std = { version = \"1.12.0\", features = [\"attributes\"] }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "48bafc08-56cc-4b35-b325-a8e5972a7392",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[async_std::test]\n",
    "async fn test_async_function() {\n",
    "    let result = async_function().await;\n",
    "    assert_eq!(result, 42);\n",
    "}\n",
    "\n",
    "async fn async_function() -> i32 {\n",
    "    async_std::task::sleep(std::time::Duration::from_secs(1)).await;\n",
    "    42\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f89e73dd-b939-4454-b119-39e866e00c79",
   "metadata": {},
   "source": [
    "### Mocking Dependencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "d1dd1327-3aed-47e5-acce-90b599377b58",
   "metadata": {},
   "outputs": [],
   "source": [
    ":dep mockall = { version = \"0.12.0\" }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "f6dc3264-b825-458e-b0fc-66f031d3d71a",
   "metadata": {},
   "outputs": [],
   "source": [
    "use mockall::automock;\n",
    "\n",
    "#[automock]\n",
    "pub trait ExternalDependency {\n",
    "    fn do_something(&self) -> i32;\n",
    "}\n",
    "\n",
    "#[cfg(test)]\n",
    "mod tests {\n",
    "    use super::*;\n",
    "\n",
    "    #[test]\n",
    "    fn test_with_mocked_dependency() {\n",
    "        let mut dependency = MockExternalDependency::default();\n",
    "\n",
    "        dependency.expect_do_something().returning(|| 42);\n",
    "\n",
    "        let result = code_under_test(&dependency);\n",
    "\n",
    "        assert_eq!(result, 42);\n",
    "    }\n",
    "\n",
    "    fn code_under_test(external_dep: &dyn ExternalDependency) -> i32 {\n",
    "        external_dep.do_something()\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de22160c-a8ed-4117-83bc-85a37ab9b302",
   "metadata": {},
   "source": [
    "### Testing Private Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "3ae031df-ca4c-4705-b94f-72f93090814c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#[cfg(test)]\n",
    "mod tests {\n",
    "    use super::private_function;\n",
    "\n",
    "    #[test]\n",
    "    fn test_private_function() {\n",
    "        let result = private_function(3);\n",
    "        assert_eq!(result, 6);\n",
    "    }\n",
    "}\n",
    "\n",
    "#[allow(dead_code)]\n",
    "fn private_function(x: i32) -> i32 {\n",
    "    x * 2\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e1662e-359d-4647-8110-733964c7ddfc",
   "metadata": {},
   "source": [
    "### Benchmarking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c3544d7-598e-43c7-9277-e29dbaf906fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#![feature(test)]\n",
    "\n",
    "extern crate test;\n",
    "\n",
    "use test::Bencher;\n",
    "\n",
    "#[bench]\n",
    "fn bench_example(b: &mut Bencher) {\n",
    "    b.iter(|| {\n",
    "        let result = expensive_computation();\n",
    "        assert!(result > 0);\n",
    "    });\n",
    "}\n",
    "\n",
    "fn expensive_computation() -> i32 {\n",
    "    (1..1_000).sum()\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78ebdf2a-feae-47a4-aa5a-445bab21cc76",
   "metadata": {},
   "source": [
    "### Code Coverage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "84c97f02-ff97-4884-834d-bf2384ea3b6c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "    Updating crates.io index\n",
      "     Ignored package `cargo-tarpaulin v0.27.2` is already installed, use --force to override\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cargo install cargo-tarpaulin\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "561af5ad-58a6-40d4-bec7-7db8904b36fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2mDec 10 17:49:52.100\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin::config: Creating config\n",
      "\u001b[2mDec 10 17:49:52.114\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin: Running Tarpaulin\n",
      "\u001b[2mDec 10 17:49:52.114\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin: Building project\n",
      "\u001b[2mDec 10 17:49:52.114\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin::cargo: Cleaning project\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "   Compiling basic-test-function v0.1.0 (/home/mahmoud/Desktop/Rust Book/rust-lang-book/chapter_11/1-basic-test-function)\n",
      "    Finished test [unoptimized + debuginfo] target(s) in 0.31s\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[2mDec 10 17:49:52.494\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin::process_handling::linux: Launching test\n",
      "\u001b[2mDec 10 17:49:52.494\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin::process_handling: running /home/mahmoud/Desktop/Rust Book/rust-lang-book/chapter_11/1-basic-test-function/target/debug/deps/basic_test_function-ab5a076178427322\n",
      "\n",
      "running 1 test\n",
      "test test_complex_addition ... ok\n",
      "\n",
      "test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s\n",
      "\n",
      "\u001b[2mDec 10 17:49:53.146\u001b[0m \u001b[32m INFO\u001b[0m cargo_tarpaulin::report: Coverage Results:\n",
      "|| Tested/Total Lines:\n",
      "|| src/main.rs: 2/2 +0.00%\n",
      "|| \n",
      "100.00% coverage, 2/2 lines covered, +0.00% change in coverage\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "let command = \"cd 1-basic-test-function && cargo tarpaulin --out Xml\";\n",
    "\n",
    "if let Err(err) = execute_command(command) {\n",
    "    eprintln!(\"Error executing command: {}\", err);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d426478a-fda8-4d44-95ca-b12e631d8c3f",
   "metadata": {},
   "source": [
    "---\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}