wk7/MY470_wk7_lecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### MY470 Computer Programming\n",
    "# Testing and Debugging in Python\n",
    "### Week 7 Lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Overview\n",
    "\n",
    "* Testing\n",
    "    * Random, black-box, and glass-box testing\n",
    "    * Unit, regression, and integration testing\n",
    "* Debugging\n",
    "    * Overt and covert bugs\n",
    "    * Persistent and intermittent bugs\n",
    "    * Debugging strategies and techniques\n",
    "* Defensive programming\n",
    "    * Exceptions\n",
    "    * Assertions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Testing\n",
    "\n",
    "* Running a program to confirm that it works as intended\n",
    "\n",
    "## Debugging\n",
    "\n",
    "* Fixing a program that does not work as intended"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Design Your Programs to Facilitate Testing and Debugging\n",
    "\n",
    "1. ⚙️ Break program into separate components (functions and classes)\n",
    "\n",
    "2. 📖 Document constraints using function specifications\n",
    "\n",
    "3. 📖 Document assumptions and logic using code comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Random Testing\n",
    "\n",
    "* Explore a large set of random values\n",
    "\n",
    "## Black-Box Testing\n",
    "\n",
    "* Focus on the specification\n",
    "\n",
    "## Glass-Box Testing\n",
    "\n",
    "* Focus on the code\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Black-Box Testing\n",
    "\n",
    "* Tester is presumed ignorant of the code\n",
    "* Focus on the specification\n",
    "* Robust to changes in the implementation\n",
    "\n",
    "### Test all natural partitions\n",
    "\n",
    "*  E.g., for numbers, test a negative number, `0`, integer, and float (if in specification)\n",
    "\n",
    "### Test boundary conditions\n",
    "\n",
    "* E.g., for lists, test for `[], ['one element'], [['list'], ['of'], ['lists']]`, and aliasing\n",
    "\n",
    "### Test extremes\n",
    "\n",
    "* E.g., for numbers, test for very small, typical, and very large values\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example: Black-Box Testing\n",
    "\n",
    "```\n",
    "def sqrt(x, eps):\n",
    "    \"\"\"Assumes x, eps floats, x >= 0, eps > 0.\n",
    "    Returns res such that x - eps <= res*res <= x + eps.\n",
    "    \"\"\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Case   | x  | eps   \n",
    "| :----: |:------:| :----------------------\n",
    "| boundary | 0         | 0.0001            \n",
    "| natural partition | 25    | 0.0001  \n",
    "| natural partition | 0.5    | 0.0001 \n",
    "| natural partition | 2    | 0.0001 \n",
    "| extreme | 2    | 0.5\\*\\*64\n",
    "| extreme | 0.5\\*\\*64  | 0.5\\*\\*64\n",
    "| extreme | 2\\*\\*64    | 0.5\\*\\*64\n",
    "| extreme | 0.5\\*\\*64  | 2\\*\\*64\n",
    "| extreme | 2\\*\\*64    | 2\\*\\*64\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Glass-Box Testing\n",
    "\n",
    "* Focus on the code\n",
    "* Easier to construct and make more thorough\n",
    "\n",
    "### Aim for path-complete glass-box tests — testing every possible path through the program\n",
    "\n",
    "* Test both branches of `if` statetments\n",
    "* Test  all `except` clauses\n",
    "* For `for` loops, test not entering loop, entering once, and entering multiple times\n",
    "* For `while` loops, test not entering loop, entering once, entering multiple times, and exiting the loop in every possible way\n",
    "* For recursive functions, test no recursive calls, one recursive call, and multiple recursive calls\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example: Glass-Box Testing\n",
    "\n",
    "```\n",
    "def abs(x):\n",
    "    \"\"\"Assumes x is an int.\n",
    "    Returns x if x >= 0 and -x otherwise.\n",
    "    \"\"\"\n",
    "    if x < -1:\n",
    "        return -x\n",
    "    else:\n",
    "        return x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* Path complete test: 2 and -2\n",
    "* But `abs(-1)` returns `-1`!\n",
    "* Always combine with black-box testing!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conducting Tests\n",
    "\n",
    "1. **Make sure code runs** — remove syntax or static semantic errors\n",
    "2. **Unit testing** — test individual functions and methods\n",
    "3. **Regression testing** — fix bugs and perform 2) again\n",
    "4. **Integration testing** — test the program as a whole\n",
    "\n",
    "\n",
    "## If test fails:\n",
    "\n",
    "* Fix bug in code\n",
    "* Modify specification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example: Unit Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Example taken from Gries et al. 2013. Practical Programming: An Introduction \n",
    "# to Computer Science Using Python 3\n",
    "\n",
    "def running_sum(ls):\n",
    "    \"\"\"Modify list ls so that it contains the running sums of its original items.\n",
    "    E.g., running_sum([1, 2, 3]) updates the list to [1, 3, 6].\n",
    "    \"\"\"\n",
    "    \n",
    "    for i in range(len(ls)):\n",
    "        ls[i] = ls[i - 1] + ls[i]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "| Case   | List before  | List after   \n",
    "| :----: |:------:| :----------------------\n",
    "| Empty list | `[]`         | `[]`           \n",
    "| One-item list | `[2]`    | `[2]`  \n",
    "| Two-item list | `[2, 5]`    | `[2, 7]` \n",
    "| Multiple items, all negative | `[-1, -5, -3, -4]`    | `[-1, -6, -9, -13]` \n",
    "| Multiple items, all positive | `[4, 2, 3, 6]`    | `[4, 6, 9, 15]`\n",
    "| Multiple items, all zero | `[0, 0, 0, 0]`  | `[0, 0, 0, 0]`\n",
    "| Multiple items, mixed | `[4, 0, 2, -5]`    | `[4, 4, 6, 1]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example: Unit Testing with `unittest`\n",
    "\n",
    "https://docs.python.org/3/library/unittest.html\n",
    "\n",
    "Let's look at files `tools.py` and `tests.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![Test fails](figs/test_fails.png \"Test fails\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Example: Unit Testing with `unittest`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# Modify the function in the file tools.py as shown below\n",
    "\n",
    "def running_sum(ls):\n",
    "    \"\"\"Modify list ls so that it contains the running sums of its original items.\n",
    "    E.g., running_sum([1, 2, 3]) updates the list to [1, 3, 6].\n",
    "    \"\"\"\n",
    "    for i in range(1, len(ls)):\n",
    "        ls[i] = ls[i - 1] + ls[i]\n",
    "        \n",
    "# Then run the tests again        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "![Test ok](figs/test_ok.png \"Test ok\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## [Debugging](https://www.youtube.com/watch?v=ocwnns57cYQ)\n",
    "\n",
    ">Debugging  is twice as hard as writing the code in the first place.\n",
    ">Therefore, if  you write the code as cleverly as possible, you are, \n",
    ">by  definition,  not smart enough to debug it. \n",
    "\n",
    ">– *Brian W. Kernighan*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types of Bugs\n",
    "\n",
    "![Types of bugs](figs/bugs_types.png \"Types of bugs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Types of Bugs\n",
    "\n",
    "![Challenges of bugs](figs/bugs_difficulty.png \"Challenges of bugs\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## How to Debug in Two Easy Steps\n",
    "\n",
    "1. Use `print()`\n",
    "2. Be systematic\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Debugging with `print()`\n",
    "\n",
    "### Version 1\n",
    "\n",
    "* Print when function is entered, print the parameters, print the results\n",
    "\n",
    "### Version 2\n",
    "\n",
    "* Put `print()` halfway in code and use bisection method to identify the problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Systematic Debugging\n",
    "\n",
    "1. Compare input in successful and failing runs\n",
    "2. Formulate a hypothesis\n",
    "3. Design an experiment to test the hypothesis; use `print()`\n",
    "4. Keep record of your experiment\n",
    "5. Repeat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Additional Debugging Strategies\n",
    "\n",
    "* Use `try` and `except` to identify which inputs/data give the error \n",
    "* Watch out for the usual suspects — aliasing, failure to reinitialize a variable, testing equality between two floats, improper indentation, misspelling variable name, etc.\n",
    "* Stop debugging and start documenting your code/explaining it to someone else\n",
    "* Re-write the code using another approach\n",
    "* Sleep on it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Obligatory Nerdy Joke about Debugging\n",
    "\n",
    ">A physicist, an engineer, and a programmer are in a car driving over a steep alpine pass when the brakes fail. The car is getting faster and faster, they are struggling to get round the corners and once or twice only the feeble crash barrier saves them from crashing down the side of the mountain. They are sure they are all going to die, when suddenly they spot an escape lane. They pull into the escape lane, and come safely to a halt.\n",
    ">\n",
    ">The physicist says: \"We need to model the friction in the brake pads and the resultant temperature rise, see if we can work out why they failed.\"\n",
    ">\n",
    ">The engineer says: \"I think I've got a few spanners in the back. I'll take a look and see if I can work out what's wrong.\"\n",
    ">\n",
    ">The programmer says: \"Why don't we get going again and see if it's reproducible?\"\n",
    "\n",
    "Source: https://www.quora.com/What-are-the-most-popular-computer-programming-jokes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defensive Programming\n",
    "\n",
    "![Defensive programming](figs/defensive_programming.png \"Defensive programming\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Defensive Programming\n",
    "\n",
    "Aims to improve programs in terms of:\n",
    "\n",
    "* Reduce number of bugs and problems\n",
    "* Make code more understandable\n",
    "* Make program behavior more predictable regardless of user input and actions\n",
    "\n",
    "Can be achieved with:\n",
    "\n",
    "* ⚙️ Modularizing programs (using functions and classes)\n",
    "* 📖 Documenting constraints (using function specifications)\n",
    "* Checking conditions on inputs and outputs (using **assertions** and handling **exceptions**)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [1, 2, 3]\n",
    "lst[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "12 / 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "If an exception is **raised** and not **handled** — the program crashes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Common Types of Exceptions\n",
    "\n",
    "* `SyntaxEror` — trying to execute something Python cannot parse\n",
    "* `IndexError` — trying to access beyond a sequence's length\n",
    "* `TypeError` — trying to use inappropriate type\n",
    "* `NameError` — referencing a non-existing variable\n",
    "* `AttributeError` — trying to access a non-existing attribute (for a class)\n",
    "* `ValueError` — trying to use inappropriate value \n",
    "* `IOError` — most often, file not found"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Hierarchy of the Exception Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "BaseException\n",
    " +-- SystemExit\n",
    " +-- KeyboardInterrupt\n",
    " +-- GeneratorExit\n",
    " +-- Exception\n",
    "      +-- StopIteration\n",
    "      +-- StopAsyncIteration\n",
    "      +-- ArithmeticError\n",
    "      |    +-- FloatingPointError\n",
    "      |    +-- OverflowError\n",
    "      |    +-- ZeroDivisionError\n",
    "      +-- AssertionError\n",
    "      +-- AttributeError\n",
    "      +-- BufferError\n",
    "      +-- EOFError\n",
    "      +-- ImportError\n",
    "      +-- LookupError\n",
    "      |    +-- IndexError\n",
    "      |    +-- KeyError\n",
    "      +-- MemoryError\n",
    "      +-- NameError\n",
    "      |    +-- UnboundLocalError\n",
    "      +-- OSError\n",
    "      |    +-- BlockingIOError\n",
    "      |    +-- ChildProcessError\n",
    "      |    +-- ConnectionError\n",
    "      |    |    +-- BrokenPipeError\n",
    "      |    |    +-- ConnectionAbortedError\n",
    "      |    |    +-- ConnectionRefusedError\n",
    "      |    |    +-- ConnectionResetError\n",
    "      |    +-- FileExistsError\n",
    "      |    +-- FileNotFoundError\n",
    "      |    +-- InterruptedError\n",
    "      |    +-- IsADirectoryError\n",
    "      |    +-- NotADirectoryError\n",
    "      |    +-- PermissionError\n",
    "      |    +-- ProcessLookupError\n",
    "      |    +-- TimeoutError\n",
    "      +-- ReferenceError\n",
    "      +-- RuntimeError\n",
    "      |    +-- NotImplementedError\n",
    "      |    +-- RecursionError\n",
    "      +-- SyntaxError\n",
    "      |    +-- IndentationError\n",
    "      |         +-- TabError\n",
    "      +-- SystemError\n",
    "      +-- TypeError\n",
    "      +-- ValueError\n",
    "      |    +-- UnicodeError\n",
    "      |         +-- UnicodeDecodeError\n",
    "      |         +-- UnicodeEncodeError\n",
    "      |         +-- UnicodeTranslateError\n",
    "      +-- Warning\n",
    "           +-- DeprecationWarning\n",
    "           +-- PendingDeprecationWarning\n",
    "           +-- RuntimeWarning\n",
    "           +-- SyntaxWarning\n",
    "           +-- UserWarning\n",
    "           +-- FutureWarning\n",
    "           +-- ImportWarning\n",
    "           +-- UnicodeWarning\n",
    "           +-- BytesWarning\n",
    "           +-- ResourceWarning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Handling All Exceptions with `try` and `except`\n",
    "\n",
    "* If you know that a line of code may raise an exception when executed — handle it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def div(a, b):\n",
    "    \"\"\"Returns the result from dividing a by b.\"\"\"\n",
    "    try:\n",
    "        return a / b\n",
    "    except:\n",
    "        print(\"Cannot divide given values.\")\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Handling Specific Exceptions with `try` and `except`\n",
    "\n",
    "* If you know that a line of code may raise an exception when executed — handle it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def div(a, b):\n",
    "    \"\"\"Returns the result from dividing a by b.\"\"\"\n",
    "    try:\n",
    "        return a / b\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Division by zero is undefined.\")\n",
    "    except TypeError:\n",
    "        print(\"Function should be used with numerical types.\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `try`, `except`, `else`\n",
    "\n",
    "* Continue if no exception has been raised"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def div_add(a, b, c):\n",
    "    \"\"\"Returns a/b + c.\"\"\"\n",
    "    try:\n",
    "        x = a / b\n",
    "    except:\n",
    "        print('Cannot divide', a, 'by', b)\n",
    "    else:\n",
    "        try:\n",
    "            return x + c\n",
    "        except:\n",
    "            print('Cannot add', c)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `try`, `except`, `finally`\n",
    "\n",
    "* Execute **always**, regardless of whether exception has been raised or handled and `return` called\n",
    "* Good for clean-up, e.g. closing a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def div(a, b):\n",
    "    \"\"\"Prints the result from dividing a by b.\"\"\"\n",
    "    try:\n",
    "        print(a / b)\n",
    "    except ZeroDivisionError:\n",
    "        print(\"Division by zero is undefined.\")\n",
    "    finally:\n",
    "        print(\"This will always print.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `try`, `except`, `finally`: Exercise\n",
    "\n",
    "What is the output of the given code? Why?\n",
    "\n",
    "```\n",
    "def myfunc():\n",
    "    try:\n",
    "        return 1\n",
    "    finally: \n",
    "        return 2\n",
    "    \n",
    "print(myfunc())\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Raising Exceptions with `raise`\n",
    "\n",
    "**Instead of failing silently and double-guessing wrong inputs, alert user that something has gone wrong and stop execution!**\n",
    "\n",
    "\n",
    "```\n",
    "raise ExceptionName(arguments)\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "`ExceptionName` can be:\n",
    "* a built-in exception such as `ValueError`\n",
    "* a custom exception defined as a subclass of the built-in class `Exception`\n",
    "\n",
    "`arguments` is typically a string as a single argument to describe why the exception is raised"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Custom Exceptions\n",
    "\n",
    "* Define as a subclass of the built-in class `Exception`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "class ValidationException(Exception):\n",
    "    pass\n",
    "\n",
    "raise ValidationException('Input cannot be validated')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assertions\n",
    "\n",
    "```\n",
    "assert Boolean\n",
    "assert Boolean, argument\n",
    "```\n",
    "\n",
    "* If `False`, an `AssertionError` exception is raised\n",
    "* Useful for debugging \n",
    "* Good for defensive programming, e.g. confirming that arguments to a function are of appropriate type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def give_me_int(a):\n",
    "    assert type(a) == int, \"Argument is not an integer\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Testing and Debugging in Python\n",
    "\n",
    "* Debugging is an essential part of programming\n",
    "* Efficient debugging takes experience\n",
    "\n",
    "* Including a testing suite is essential for releasing modules and packages to the public\n",
    "* But you should always \"informally\" test your code while programming. This will ultimately reduce debugging!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "-------\n",
    "\n",
    "* **Lab**: Working with .py files, practicing unit testing, exceptions, and assertions. GitHub Copilot.\n",
    "* **Next week**: R"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Work on PS4 with GitHub Copilot\n",
    "\n",
    "1. Unit tests are important but tedious to write\n",
    "2. GitHub Copilot is an AI tool that can assist you by autocompleting code. Powerful and useful, but be **very wary** of the code it produces!\n",
    "3. First, make sure you **claim your GitHub student benefits from [GitHub Education](https://education.github.com/discount_requests/application)**. These give you free access to Copilot.\n",
    "4. Then, **install the GitHub Copilot extension in VS Code**. It will ask you for your GitHub log in so that it gets activated.\n",
    "5. We will demo and give further advice in class."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}