Python_Regex_Assignment2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "427965b0-0558-4709-bb73-7e71dba0a2ab",
      "metadata": {
        "id": "427965b0-0558-4709-bb73-7e71dba0a2ab"
      },
      "source": [
        "# Python Regex Part 2 : Quantifiers - Assignment"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "8ba1bdc9-c0de-4590-ac72-885ee3da2064",
      "metadata": {
        "id": "8ba1bdc9-c0de-4590-ac72-885ee3da2064"
      },
      "source": [
        "**Question 1** Check if a string contains one or more digits\n",
        "\n",
        "**Description:** Write a function that checks if a string contains one or more digits.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"abc123\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"abc\"\n",
        "\n",
        "Output: False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "2e28d098-4464-4526-abe1-e602c120e9c7",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2e28d098-4464-4526-abe1-e602c120e9c7",
        "outputId": "1417fc97-f92d-46b2-b7f5-e838a952247e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does abc123 contains one or more digits?\n",
            "Answer: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does abc contains one or more digits?\n",
            "Answer: False\n",
            "Test Case 2 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_have_digits(sentence):\n",
        "  # another pattern which can be used is r'\\d{1,}'\n",
        "  if re.search(r'^\\w*\\d{1,}\\w*$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "\n",
        "# main() code\n",
        "print(\"Test Case 1 Running...\")\n",
        "text = \"abc123\"\n",
        "print(f\"Question: Does {text} contains one or more digits?\\nAnswer: {check_text_have_digits(text)}\")\n",
        "if check_text_have_digits(text) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "print(\"Test Case 2 Running...\")\n",
        "text = \"abc\"\n",
        "print(f\"Question: Does {text} contains one or more digits?\\nAnswer: {check_text_have_digits(text)}\")\n",
        "if check_text_have_digits(text) == False:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "97a9a0d8-6f03-4fb7-8e62-c369621af151",
      "metadata": {
        "id": "97a9a0d8-6f03-4fb7-8e62-c369621af151"
      },
      "source": [
        "**Question 2:** Check if a string contains zero or more lowercase letters followed by zero or more digits\n",
        "\n",
        "**Description:** Write a function that checks if a string contains zero or more lowercase letters followed by zero or more digits.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"abc123\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"123\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"abc\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"ABC\"\n",
        "\n",
        "Output: False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "493368bd-afbd-428c-ad8d-41b198fc0f48",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "493368bd-afbd-428c-ad8d-41b198fc0f48",
        "outputId": "4ef4a48c-e186-4442-e42d-50135f840c4c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does abc123 contains 0 or more lower-case letters followed by 0 or more digits?\n",
            "Answer: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does 123 contains 0 or more lower-case letters followed by 0 or more digits?\n",
            "Answer: True\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "Question: Does abc contains 0 or more lower-case letters followed by 0 or more digits?\n",
            "Answer: True\n",
            "Test Case 3 Passed!\n",
            "\n",
            "Test Case 4 Running...\n",
            "Question: Does ABC contains 0 or more lower-case letters followed by 0 or more digits?\n",
            "Answer: False\n",
            "Test Case 4 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(sentence):\n",
        "  if re.search(r'^[a-z]*\\d*$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "# main() code\n",
        "# Test-Case 1\n",
        "print(\"Test Case 1 Running...\")\n",
        "input_text = \"abc123\"\n",
        "print(f\"Question: Does {input_text} contains 0 or more lower-case letters followed by 0 or more digits?\\nAnswer: {check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text)}\")\n",
        "if check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 2\n",
        "print(\"Test Case 2 Running...\")\n",
        "input_text = \"123\"\n",
        "print(f\"Question: Does {input_text} contains 0 or more lower-case letters followed by 0 or more digits?\\nAnswer: {check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text)}\")\n",
        "if check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text) == True:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 3\n",
        "print(\"Test Case 3 Running...\")\n",
        "input_text = \"abc\"\n",
        "print(f\"Question: Does {input_text} contains 0 or more lower-case letters followed by 0 or more digits?\\nAnswer: {check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text)}\")\n",
        "if check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text) == True:\n",
        "  print(\"Test Case 3 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 3 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 4\n",
        "print(\"Test Case 4 Running...\")\n",
        "input_text = \"ABC\"\n",
        "print(f\"Question: Does {input_text} contains 0 or more lower-case letters followed by 0 or more digits?\\nAnswer: {check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text)}\")\n",
        "if check_text_have_zero_or_more_lowercaseletter_followed_by_zero_or_more_digits(input_text) == False:\n",
        "  print(\"Test Case 4 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 4 Failed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "7b059cea-62c0-4ad2-aea2-0fd739ca1c58",
      "metadata": {
        "id": "7b059cea-62c0-4ad2-aea2-0fd739ca1c58"
      },
      "source": [
        "**Question3:** Check if a string contains exactly 4 digits\n",
        "\n",
        "**Description:** Write a function that checks if a string contains exactly 4 digits.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"1234\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"12345\"\n",
        "\n",
        "Output: False\n",
        "\n",
        "Input: \"abc1234\"\n",
        "\n",
        "Output: True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9f4e87b9-0af4-4407-a0a8-6665e6e1cd7d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9f4e87b9-0af4-4407-a0a8-6665e6e1cd7d",
        "outputId": "d58af65e-26a4-49e5-f508-d10ec5ccf8ae"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does 1234 contains exactly 4 digits?\n",
            "Answer True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does 12345 contains exactly 4 digits?\n",
            "Answer: False\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "Question: Does abc1234 contains exactly 4 digits?\n",
            "Answer True\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_contains_exactly_four_digits(sentence):\n",
        "  if re.search(r'^[a-zA-Z]*\\d{4}[a-zA-Z]*$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "# main() code\n",
        "# Test-Case 1\n",
        "print(\"Test Case 1 Running...\")\n",
        "inp_txt = \"1234\"\n",
        "print(f\"Question: Does {inp_txt} contains exactly 4 digits?\\nAnswer {check_text_contains_exactly_four_digits(inp_txt)}\")\n",
        "if check_text_contains_exactly_four_digits(inp_txt) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 2\n",
        "print(\"Test Case 2 Running...\")\n",
        "inp_txt = \"12345\"\n",
        "print(f\"Question: Does {inp_txt} contains exactly 4 digits?\\nAnswer: {check_text_contains_exactly_four_digits(inp_txt)}\")\n",
        "if check_text_contains_exactly_four_digits(inp_txt) == False:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 3\n",
        "print(\"Test Case 3 Running...\")\n",
        "inp_txt = \"abc1234\"\n",
        "print(f\"Question: Does {inp_txt} contains exactly 4 digits?\\nAnswer {check_text_contains_exactly_four_digits(inp_txt)}\")\n",
        "if check_text_contains_exactly_four_digits(inp_txt) == True:\n",
        "  print(\"Test Case 3 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 3 Failed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "c58f5a50-fdfd-45e5-a5ef-b891ed4af06c",
      "metadata": {
        "id": "c58f5a50-fdfd-45e5-a5ef-b891ed4af06c"
      },
      "source": [
        "**Question 4**: Check if a string contains between 2 and 4 lowercase letters\n",
        "\n",
        "**Description:** Write a function that checks if a string contains between 2 and 4 lowercase letters.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"abc\"\n",
        "    \n",
        "Output: True\n",
        "\n",
        "Input: \"a\"\n",
        "\n",
        "Output: False\n",
        "\n",
        "Input: \"abcdef\"\n",
        "\n",
        "Output: False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bcbc5031-710b-4ef1-a07d-0799329d967d",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bcbc5031-710b-4ef1-a07d-0799329d967d",
        "outputId": "48e32502-ac17-49b6-99ce-13a78aea5e9d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does abc contains between 2 and 4 lower-case letters?\n",
            "Answer: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does a contains between 2 and 4 lower-case letters?\n",
            "Answer: False\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "Question: Does abcdef contains between 2 and 4 lower-case letters?\n",
            "Answer: False\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_contains_lowercase_letter_between_two_and_four_letter_count(sentence):\n",
        "  if re.search(r'^[A-Z0-9]*[a-z]{2,4}[A-Z0-9]*$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "# main() code\n",
        "# Test-Case 1\n",
        "print(\"Test Case 1 Running...\")\n",
        "txt_inp = \"abc\"\n",
        "print(f\"Question: Does {txt_inp} contains between 2 and 4 lower-case letters?\\nAnswer: {check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp)}\")\n",
        "if check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 2\n",
        "print(\"Test Case 2 Running...\")\n",
        "txt_inp = \"a\"\n",
        "print(f\"Question: Does {txt_inp} contains between 2 and 4 lower-case letters?\\nAnswer: {check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp)}\")\n",
        "if check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp) == False:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 3\n",
        "print(\"Test Case 3 Running...\")\n",
        "txt_inp = \"abcdef\"\n",
        "print(f\"Question: Does {txt_inp} contains between 2 and 4 lower-case letters?\\nAnswer: {check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp)}\")\n",
        "if check_text_contains_lowercase_letter_between_two_and_four_letter_count(txt_inp) == False:\n",
        "  print(\"Test Case 3 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 3 Failed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "0cbd2fc8-5fb6-4b69-9a20-a568d7a9e7d9",
      "metadata": {
        "id": "0cbd2fc8-5fb6-4b69-9a20-a568d7a9e7d9"
      },
      "source": [
        "**Question 5** Check if a string contains at least 3 uppercase letters\n",
        "\n",
        "**Description:** Write a function that checks if a string contains at least 3 uppercase letters.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"ABC\"\n",
        "    \n",
        "Output: True\n",
        "\n",
        "Input: \"AB\"\n",
        "\n",
        "Output: False\n",
        "\n",
        "Input: \"AABBCC\"\n",
        "\n",
        "Output: True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "782acfea-160a-4ce2-ac42-a4ba9dddabbd",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "782acfea-160a-4ce2-ac42-a4ba9dddabbd",
        "outputId": "0b7a6618-205c-470c-d55e-fd2c4c506e77"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does ABC contains atleast 3 upper-case letters?\n",
            "Answer: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does AB contains atleast 3 upper-case letters?\n",
            "Answer: False\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "Question: Does AABBCC contains atleast 3 upper-case letters?\n",
            "Answer: True\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_contains_at_least_three_uppercase_letters(sentence):\n",
        "  if re.search(r'^[a-z0-9]*[A-Z]{3,}[a-z0-9]*$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "# main() code\n",
        "# Test-Case 1\n",
        "print(\"Test Case 1 Running...\")\n",
        "text_string_input = \"ABC\"\n",
        "print(f\"Question: Does {text_string_input} contains atleast 3 upper-case letters?\\nAnswer: {check_text_contains_at_least_three_uppercase_letters(text_string_input)}\")\n",
        "if check_text_contains_at_least_three_uppercase_letters(text_string_input) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 2\n",
        "print(\"Test Case 2 Running...\")\n",
        "text_string_input = \"AB\"\n",
        "print(f\"Question: Does {text_string_input} contains atleast 3 upper-case letters?\\nAnswer: {check_text_contains_at_least_three_uppercase_letters(text_string_input)}\")\n",
        "if check_text_contains_at_least_three_uppercase_letters(text_string_input) == False:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 3\n",
        "print(\"Test Case 3 Running...\")\n",
        "text_string_input = \"AABBCC\"\n",
        "print(f\"Question: Does {text_string_input} contains atleast 3 upper-case letters?\\nAnswer: {check_text_contains_at_least_three_uppercase_letters(text_string_input)}\")\n",
        "if check_text_contains_at_least_three_uppercase_letters(text_string_input) == True:\n",
        "  print(\"Test Case 3 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 3 Failed!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "id": "4a27a54c-e1c2-495a-aa23-3179021683b8",
      "metadata": {
        "id": "4a27a54c-e1c2-495a-aa23-3179021683b8"
      },
      "source": [
        "**Question 6** Check if a string contains zero or one instance of the word \"hello\"\n",
        "\n",
        "**Description:** Write a function that checks if a string contains zero or one instance of the word \"hello\".\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"hello\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"hellohello\"\n",
        "\n",
        "Output: False\n",
        "\n",
        "Input: \"hi\"\n",
        "\n",
        "Output: True"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "3bf8d26a-c59e-41fb-8787-89ed7608d542",
      "metadata": {
        "id": "3bf8d26a-c59e-41fb-8787-89ed7608d542"
      },
      "outputs": [],
      "source": [
        "# in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "49b8e22d-d577-4666-8061-e24904e62573",
      "metadata": {
        "id": "49b8e22d-d577-4666-8061-e24904e62573"
      },
      "source": [
        "**Question 7** Check if a string contains at least 5 vowels\n",
        "\n",
        "**Description:** Write a function that checks if a string contains at least 5 vowels.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"education\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"aeiou\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"hello\"\n",
        "\n",
        "Output: False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9e74fcc1-8e9e-4a0e-ae81-ed1201ceaa9b",
      "metadata": {
        "id": "9e74fcc1-8e9e-4a0e-ae81-ed1201ceaa9b"
      },
      "outputs": [],
      "source": [
        "# in-processing..."
      ]
    },
    {
      "cell_type": "markdown",
      "id": "3d4625ad-3ec3-42b9-8ca9-f032f849e8ef",
      "metadata": {
        "id": "3d4625ad-3ec3-42b9-8ca9-f032f849e8ef"
      },
      "source": [
        "**Question 8** Check if a string contains an optional \"www.\" followed by a domain name\n",
        "\n",
        "**Description:**  Write a function that checks if a string contains an optional \"www.\" followed by a domain name.\n",
        "\n",
        "**Input and Expected Output:**\n",
        "\n",
        "Input: \"www.example.com\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"example.com\"\n",
        "\n",
        "Output: True\n",
        "\n",
        "Input: \"example\"\n",
        "\n",
        "Output: False"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "e98bd7ff-44a1-499e-8f83-634e39fa1548",
      "metadata": {
        "id": "e98bd7ff-44a1-499e-8f83-634e39fa1548",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a159787c-6d7a-4645-ede1-9f449978afc1"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Case 1 Running...\n",
            "Question: Does www.example.com contains domain name?\n",
            "Answer: True\n",
            "Test Case 1 Passed!\n",
            "\n",
            "Test Case 2 Running...\n",
            "Question: Does example.com contains domain name?\n",
            "Answer: True\n",
            "Test Case 2 Passed!\n",
            "\n",
            "Test Case 3 Running...\n",
            "Question: Does example contains domain name?\n",
            "Answer: False\n",
            "Test Case 3 Passed!\n"
          ]
        }
      ],
      "source": [
        "import re\n",
        "\n",
        "def check_text_contains_domain_name(sentence):\n",
        "  if re.search(r'^[www.]*[a-zA-Z]{3,}\\.[a-zA-Z]{2,}$', sentence):\n",
        "    return True\n",
        "\n",
        "  return False\n",
        "\n",
        "\n",
        "# main() code\n",
        "# Test-Case 1\n",
        "print(\"Test Case 1 Running...\")\n",
        "string_input_text = \"www.example.com\"\n",
        "print(f\"Question: Does {string_input_text} contains domain name?\\nAnswer: {check_text_contains_domain_name(string_input_text)}\")\n",
        "if check_text_contains_domain_name(string_input_text) == True:\n",
        "  print(\"Test Case 1 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 1 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 2\n",
        "print(\"Test Case 2 Running...\")\n",
        "string_input_text = \"example.com\"\n",
        "print(f\"Question: Does {string_input_text} contains domain name?\\nAnswer: {check_text_contains_domain_name(string_input_text)}\")\n",
        "if check_text_contains_domain_name(string_input_text) == True:\n",
        "  print(\"Test Case 2 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 2 Failed!\")\n",
        "\n",
        "print()\n",
        "\n",
        "# Test-Case 3\n",
        "print(\"Test Case 3 Running...\")\n",
        "string_input_text = \"example\"\n",
        "print(f\"Question: Does {string_input_text} contains domain name?\\nAnswer: {check_text_contains_domain_name(string_input_text)}\")\n",
        "if check_text_contains_domain_name(string_input_text) == False:\n",
        "  print(\"Test Case 3 Passed!\")\n",
        "else:\n",
        "  print(\"Test Case 3 Failed!\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3 (ipykernel)",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.4"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}