Python2016_Wyklad-08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Język Python - Wykład 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testowanie kodu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### assert\n",
    "\n",
    "* w kodzie można traktować jako dodatkową dokumentację (uruchamialną)\n",
    "* nie zastępują testów (jedynie uzupełniają je)\n",
    "* pozwalają szybciej wyłapywać bugi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "assert True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "assert False, \"Cos poszlo nie tak :-(\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "assert 2+3 == 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Niektórzy używają assertów do kontroli typów w Pythonie! (ale to jak wiemy zabija kaczki)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    assert type(a) is int, 'a is not an integer, a=%r' % a\n",
    "    assert type(b) is int, 'b is not an integer, b=%r' % b\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "add(3, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "add(4.0, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Asercję można wyłączać! (np. na produkcji ze względów wydajnościowych!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## doctest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def add(a, b):\n",
    "    \"\"\"\n",
    "    Zwraca sumę dwóch liczb, np:\n",
    "    \n",
    "    >>> add(1, 2)\n",
    "    3\n",
    "    \n",
    "    >>> add(1, '2')\n",
    "    Traceback (most recent call last):\n",
    "    ...\n",
    "    TypeError: unsupported operand type(s) for +: 'int' and 'str'\n",
    "    \"\"\"\n",
    "    return a + b \n",
    "\n",
    "import doctest\n",
    "doctest.testmod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    \"\"\"Return the factorial of n, an exact integer >= 0.\n",
    "\n",
    "    >>> [factorial(n) for n in range(6)]\n",
    "    [1, 1, 2, 6, 24, 120]\n",
    "    >>> factorial(30)\n",
    "    265252859812191058636308480000000\n",
    "    >>> factorial(-1)\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    ValueError: n must be >= 0\n",
    "\n",
    "    Factorials of floats are OK, but the float must be an exact integer:\n",
    "    >>> factorial(30.1)\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    ValueError: n must be exact integer\n",
    "    >>> factorial(30.0)\n",
    "    265252859812191058636308480000000\n",
    "\n",
    "    It must also not be ridiculously large:\n",
    "    >>> factorial(1e100)\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    OverflowError: n too large\n",
    "    \"\"\"\n",
    "\n",
    "    import math\n",
    "    if not n >= 0:\n",
    "        raise ValueError(\"n must be >= 0\")\n",
    "    if math.floor(n) != n:\n",
    "        raise ValueError(\"n must be exact integer\")\n",
    "    if n+1 == n:  # catch a value like 1e300\n",
    "        raise OverflowError(\"n too large\")\n",
    "    result = 1\n",
    "    factor = 2\n",
    "    while factor <= n:\n",
    "        result *= factor\n",
    "        factor += 1\n",
    "    return result\n",
    "\n",
    "\n",
    "import doctest\n",
    "doctest.testmod()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "$ python factorial.py -v\n",
    "\n",
    "Trying:\n",
    "    [factorial(n) for n in range(6)]\n",
    "Expecting:\n",
    "    [1, 1, 2, 6, 24, 120]\n",
    "ok\n",
    "Trying:\n",
    "    factorial(30)\n",
    "Expecting:\n",
    "    265252859812191058636308480000000\n",
    "ok\n",
    "Trying:\n",
    "    factorial(-1)\n",
    "Expecting:\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    ValueError: n must be >= 0\n",
    "ok\n",
    "Trying:\n",
    "    factorial(30.1)\n",
    "Expecting:\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    ValueError: n must be exact integer\n",
    "ok\n",
    "Trying:\n",
    "    factorial(30.0)\n",
    "Expecting:\n",
    "    265252859812191058636308480000000\n",
    "ok\n",
    "Trying:\n",
    "    factorial(1e100)\n",
    "Expecting:\n",
    "    Traceback (most recent call last):\n",
    "        ...\n",
    "    OverflowError: n too large\n",
    "ok\n",
    "1 items had no tests:\n",
    "    __main__                                                                                                                                                          \n",
    "1 items passed all tests:                                                                                                                                             \n",
    "   6 tests in __main__.factorial                                                                                                                                      \n",
    "6 tests in 2 items.                                                                                                                                                   \n",
    "6 passed and 0 failed.                                                                                                                                                \n",
    "Test passed. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### example.test"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "The ``example`` module\n",
    "======================\n",
    "\n",
    "Using ``factorial``\n",
    "-------------------\n",
    "\n",
    "This is an example text file in reStructuredText format.  First import\n",
    "``factorial`` from the ``example`` module:\n",
    "\n",
    "    >>> from example import factorial\n",
    "\n",
    "Now use it:\n",
    "\n",
    "    >>> factorial(6)\n",
    "    120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import doctest\n",
    "doctest.testfile(\"example.test\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "File \"./example.test\", line 14, in example.txt\n",
    "Failed example:\n",
    "    factorial(6)\n",
    "Expected:\n",
    "    120\n",
    "Got:\n",
    "    720"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "python -m doctest -v example.test"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "File \"./example.test\", line 14, in example.txt\n",
    "Failed example:\n",
    "    factorial(6)\n",
    "Expected:\n",
    "    120\n",
    "Got:\n",
    "    720"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def foo(*args):\n",
    "    \"\"\"\n",
    "    >>> print foo(range(10), range(4))\n",
    "    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3]\n",
    "    \n",
    "    >>> print foo(range(10), range(4)) # doctest: +ELLIPSIS\n",
    "    [0, 1, ..., 9, 0, 1, 2, 3]\n",
    "    \n",
    "    >>> print foo(range(10), range(4)) # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE\n",
    "    [0, ..., 9,    0, ..., 3]\n",
    "    \"\"\"\n",
    "    return [x for el in args for x in el]\n",
    "\n",
    "import doctest\n",
    "doctest.testmod(verbose=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unittest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import unittest\n",
    "\n",
    "class TestSequenceFunctions(unittest.TestCase):\n",
    "\n",
    "    def setUp(self):\n",
    "        self.seq = list(range(10))\n",
    "\n",
    "    def test_shuffle(self):\n",
    "        # make sure the shuffled sequence does not lose any elements\n",
    "        random.shuffle(self.seq)\n",
    "        self.seq.sort()\n",
    "        self.assertEqual(self.seq, list(range(10)))\n",
    "\n",
    "        # should raise an exception for an immutable sequence\n",
    "        self.assertRaises(TypeError, random.shuffle, (1,2,3))\n",
    "\n",
    "    def test_choice(self):\n",
    "        element = random.choice(self.seq)\n",
    "        self.assertTrue(element in self.seq)\n",
    "\n",
    "    def test_sample(self):\n",
    "        with self.assertRaises(ValueError):\n",
    "            random.sample(self.seq, 20)\n",
    "        for element in random.sample(self.seq, 5):\n",
    "            self.assertTrue(element in self.seq)\n",
    "\n",
    "suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)\n",
    "print(unittest.TextTestRunner(verbosity=3).run(suite))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import random\n",
    "import unittest\n",
    "\n",
    "class TestSequenceFunctions(unittest.TestCase):\n",
    "\n",
    "    def setUp(self):\n",
    "        self.seq = list(range(10))\n",
    "\n",
    "    def test_shuffle(self):\n",
    "        # make sure the shuffled sequence does not lose any elements\n",
    "        random.shuffle(self.seq)\n",
    "        self.seq.sort()\n",
    "        self.assertEqual(self.seq, list(range(11)))\n",
    "\n",
    "        # should raise an exception for an immutable sequence\n",
    "        self.assertRaises(TypeError, random.shuffle, (1,2,3))\n",
    "\n",
    "    def test_choice(self):\n",
    "        element = random.choice(self.seq)\n",
    "        self.assertTrue(element in self.seq)\n",
    "\n",
    "    def test_sample(self):\n",
    "        with self.assertRaises(ValueError):\n",
    "            random.sample(self.seq, 20)\n",
    "        for element in random.sample(self.seq, 5):\n",
    "            self.assertTrue(element in self.seq)\n",
    "\n",
    "suite = unittest.TestLoader().loadTestsFromTestCase(TestSequenceFunctions)\n",
    "print(unittest.TextTestRunner(verbosity=3).run(suite))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "class Widget(object):\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self._size = (50, 50)\n",
    "    \n",
    "    def size(self):\n",
    "        return self._size\n",
    "    \n",
    "    def resize(self, size):\n",
    "        self._size = size\n",
    "        \n",
    "    def dispose(self):\n",
    "        pass\n",
    "\n",
    "class WidgetTestCase(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.widget = Widget('The widget')\n",
    "\n",
    "    def tearDown(self):\n",
    "        self.widget.dispose()\n",
    "        self.widget = None\n",
    "\n",
    "    def test_default_size(self):\n",
    "        self.assertEqual(self.widget.size(), (50,50),\n",
    "                         'incorrect default size')\n",
    "\n",
    "    def test_resize(self):\n",
    "        self.widget.resize(100,150)\n",
    "        self.assertEqual(self.widget.size(), (100,150),\n",
    "                         'wrong size after resize')\n",
    "\n",
    "suite = unittest.TestLoader().loadTestsFromTestCase(WidgetTestCase)\n",
    "print(unittest.TextTestRunner(verbosity=3).run(suite))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import unittest\n",
    "\n",
    "class Widget(object):\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self._size = (50, 50)\n",
    "    \n",
    "    def size(self):\n",
    "        return self._size\n",
    "    \n",
    "    def resize(self, width, height):\n",
    "        self._size = (width, height)\n",
    "        \n",
    "    def dispose(self):\n",
    "        pass\n",
    "\n",
    "class WidgetTestCase(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.widget = Widget('The widget')\n",
    "\n",
    "    def tearDown(self):\n",
    "        self.widget.dispose()\n",
    "        self.widget = None\n",
    "\n",
    "    def test_default_size(self):\n",
    "        self.assertEqual(self.widget.size(), (50,50),\n",
    "                         'incorrect default size')\n",
    "\n",
    "    def test_resize(self):\n",
    "        self.widget.resize(100,150)\n",
    "        self.assertEqual(self.widget.size(), (100,150),\n",
    "                         'wrong size after resize')\n",
    "\n",
    "suite = unittest.TestLoader().loadTestsFromTestCase(WidgetTestCase)\n",
    "print(unittest.TextTestRunner(verbosity=3).run(suite))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "https://wiki.python.org/moin/PythonTestingToolsTaxonomy"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.4.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}