{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#default_exp test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "from local.core.imports import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from local.notebook.showdoc import *\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test\n",
    "\n",
    "> Helper functions to quickly write tests in notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple test functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can check that code raises an exception when that's expected (`test_fail`). To test for equality or inequality (with different types of things) we define a simple funciton `test` that compares two object with a given `cmp` operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_fail(f, msg='', contains=''):\n",
    "    \"Fails with `msg` unless `f()` raises an exception and (optionally) has `contains` in `e.args`\"\n",
    "    try: f()\n",
    "    except Exception as e:\n",
    "        assert not contains or contains in str(e)\n",
    "        return\n",
    "    assert False,f\"Expected exception but none raised. {msg}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def _fail(): raise Exception(\"foobar\")\n",
    "test_fail(_fail, contains=\"foo\")\n",
    "\n",
    "def _fail(): raise Exception()\n",
    "test_fail(_fail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test(a, b, cmp,cname=None):\n",
    "    \"`assert` that `cmp(a,b)`; display inputs and `cname or cmp.__name__` if it fails\"\n",
    "    if cname is None: cname=cmp.__name__\n",
    "    assert cmp(a,b),f\"{cname}:\\n{a}\\n{b}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test([1,2],[1,2], operator.eq)\n",
    "test_fail(lambda: test([1,2],[1], operator.eq))\n",
    "test([1,2],[1],   operator.ne)\n",
    "test_fail(lambda: test([1,2],[1,2], operator.ne))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"all_equal\" class=\"doc_header\"><code>all_equal</code><a href=\"https://github.com/fastai/fastai_dev/tree/master/dev/local/core/imports.py#L52\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>all_equal</code>(**`a`**, **`b`**)\n",
       "\n",
       "Compares whether `a` and `b` are the same length and have the same contents"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(all_equal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test(['abc'], ['abc'],  all_equal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"equals\" class=\"doc_header\"><code>equals</code><a href=\"https://github.com/fastai/fastai_dev/tree/master/dev/local/core/imports.py#L67\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>equals</code>(**`a`**, **`b`**)\n",
       "\n",
       "Compares `a` and `b` for equality; supports sublists, tensors and arrays too"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(equals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test([['abc'],['a']], [['abc'],['a']],  equals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def nequals(a,b):\n",
    "    \"Compares `a` and `b` for `not equals`\"\n",
    "    return not equals(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test(['abc'], ['ab' ], nequals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## test_eq test_ne, etc..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just use `test_eq`/`test_ne` to test for `==`/`!=`. `test_eq_type` check things are equals and of the same type. We define them using `test`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_eq(a,b):\n",
    "    \"`test` that `a==b`\"\n",
    "    test(a,b,equals, '==')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_eq([1,2],[1,2])\n",
    "test_eq([1,2],map(int,[1,2]))\n",
    "test_eq(array([1,2]),array([1,2]))\n",
    "test_eq(array([1,2]),array([1,2]))\n",
    "test_eq([array([1,2]),3],[array([1,2]),3])\n",
    "test_eq(dict(a=1,b=2), dict(b=2,a=1))\n",
    "test_fail(lambda: test_eq([1,2], 1), contains=\"==\")\n",
    "test_eq({'a', 'b', 'c'}, {'c', 'a', 'b'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = pd.DataFrame(dict(a=[1,2],b=['a','b']))\n",
    "df2 = pd.DataFrame(dict(a=[1,2],b=['a','b']))\n",
    "\n",
    "test_eq(df1,df2)\n",
    "test_eq(df1.a,df2.a)\n",
    "class T(pd.Series): pass\n",
    "test_eq(df1.iloc[0], T(df2.iloc[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_eq_type(a,b):\n",
    "    \"`test` that `a==b` and are same type\"\n",
    "    test_eq(a,b)\n",
    "    test_eq(type(a),type(b))\n",
    "    if isinstance(a,(list,tuple)): test_eq(map(type,a),map(type,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_eq_type(1,1)\n",
    "test_fail(lambda: test_eq_type(1,1.))\n",
    "test_eq_type([1,1],[1,1])\n",
    "test_fail(lambda: test_eq_type([1,1],(1,1)))\n",
    "test_fail(lambda: test_eq_type([1,1],[1,1.]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_ne(a,b):\n",
    "    \"`test` that `a!=b`\"\n",
    "    test(a,b,nequals,'!=')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hide_input": false
   },
   "outputs": [],
   "source": [
    "test_ne([1,2],[1])\n",
    "test_ne([1,2],[1,3])\n",
    "test_ne(array([1,2]),array([1,1]))\n",
    "test_ne(array([1,2]),array([1,1]))\n",
    "test_ne([array([1,2]),3],[array([1,2])])\n",
    "test_ne([3,4],array([3]))\n",
    "test_ne([3,4],array([3,5]))\n",
    "test_ne(dict(a=1,b=2), ['a', 'b'])\n",
    "test_ne(['a', 'b'], dict(a=1,b=2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def is_close(a,b,eps=1e-5):\n",
    "    \"Is `a` within `eps` of `b`\"\n",
    "    if hasattr(a, '__array__') or hasattr(b,'__array__'):\n",
    "        return (abs(a-b)<eps).all()\n",
    "    if isinstance(a, (Iterable,Generator)) or isinstance(b, (Iterable,Generator)):\n",
    "        return is_close(np.array(a), np.array(b), eps=eps)\n",
    "    return abs(a-b)<eps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_close(a,b,eps=1e-5):\n",
    "    \"`test` that `a` is within `eps` of `b`\"\n",
    "    test(a,b,partial(is_close,eps=eps),'close')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_close(1,1.001,eps=1e-2)\n",
    "test_fail(lambda: test_close(1,1.001))\n",
    "test_close([-0.001,1.001], [0.,1.], eps=1e-2)\n",
    "test_close(np.array([-0.001,1.001]), np.array([0.,1.]), eps=1e-2)\n",
    "test_close(array([-0.001,1.001]), array([0.,1.]), eps=1e-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_is(a,b):\n",
    "    \"`test` that `a is b`\"\n",
    "    test(a,b,operator.is_, 'is')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fail(lambda: test_is([1], [1]))\n",
    "a = [1]\n",
    "test_is(a, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_shuffled(a,b):\n",
    "    \"`test` that `a` and `b` are shuffled versions of the same sequence of items\"\n",
    "    test_ne(a, b)\n",
    "    test_eq(Counter(a), Counter(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = list(range(50))\n",
    "b = copy(a)\n",
    "random.shuffle(b)\n",
    "test_shuffled(a,b)\n",
    "test_fail(lambda:test_shuffled(a,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'abc'\n",
    "b = 'abcabc'\n",
    "test_fail(lambda:test_shuffled(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ['a', 42, True] \n",
    "b = [42, True, 'a']\n",
    "test_shuffled(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_stdout(f, exp, regex=False):\n",
    "    \"Test that `f` prints `exp` to stdout, optionally checking as `regex`\"\n",
    "    s = io.StringIO()\n",
    "    with redirect_stdout(s): f()\n",
    "    if regex: assert re.search(exp, s.getvalue()) is not None\n",
    "    else: test_eq(s.getvalue(), f'{exp}\\n' if len(exp) > 0 else '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_stdout(lambda: print('hi'), 'hi')\n",
    "test_fail(lambda: test_stdout(lambda: print('hi'), 'ho'))\n",
    "test_stdout(lambda: 1+1, '')\n",
    "test_stdout(lambda: print('hi there!'), r'^hi.*!$', regex=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_warns(f, show=False):\n",
    "    with warnings.catch_warnings(record=True) as w:\n",
    "        f()\n",
    "        test_ne(len(w), 0)\n",
    "        if show: \n",
    "            for e in w: print(f\"{e.category}: {e.message}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_warns(lambda: warnings.warn(\"Oh no!\"), {})\n",
    "test_fail(lambda: test_warns(lambda: 2+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'UserWarning'>: Oh no!\n"
     ]
    }
   ],
   "source": [
    "test_warns(lambda: warnings.warn(\"Oh no!\"), show=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "TEST_IMAGE = 'images/puppy.jpg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=128x128 at 0x7FCB344D7550>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = Image.open(TEST_IMAGE).resize((128,128)); im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "TEST_IMAGE_BW = 'images/mnist3.png'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAAAAADmVT4XAAACAElEQVR4nO3Zz6tMcRjH8Zdf6aZY+JH8B4pwN5QVWVCEsMXCQinJjmJ3V1aklLKTKwvqxkrJxoZko1gpKUk2924QyWLOmebeqTnfc+7Uozzv1czz/Z6n93zm6TszZ0iSJEmSJPnfWVK88xCcxYH6utPwE+53F1ja/dLxkALhAo1DuAxO4jqsGlr/A5dxG2ZbC4QnkAKNM7AOZrCzYeMcHMSLVgLhCaRAuMDypg3f4B4mYQW+wxfVqbSh3rgaDsshTIG2NA4huKlSXYttcATH4MG8jbuwkd6QFhGeQAqUzQDcqB9sGrFpt5yBFGhL+RD2+Txi7XnD+jDhCaRAhxkYxWt8bXVFeAIpEC6wmCE8Mw6B8ARSoPxGZZ898AQr55Vn4AR+t+oWnkAKhAt0OIjOsXAA4RZtB5B/IIEUCBfocBLuhadD5VnYj5etuoUnkAIdDqI3sA/TsL4ur4FT9fqv0m7hCaRAuECHg6jPVqo/kC8Mlq/CVGmT8ARSoHwGNsPdwcpx+Ejvbb9Sl3/AedwpaRueQAqEC5R/Gk7A9sHKY3g4VJ6D96VtwxNIgfKDaBJeFWx8B1tK24YnkALhAuUH0Sd4pvppNjbCE0iBcIGWX8snsAMu6d0MWPAKPuAovC3tGJ5ACizmp9k1uFg/m4JHqvsDxYQnkALhAkmSJEmSJMlfZ8k6HXJ7HK4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<PIL.Image.Image image mode=L size=128x128 at 0x7FCB2FC21C50>"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "im = Image.open(TEST_IMAGE_BW).resize((128,128)); im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def test_fig_exists(ax):\n",
    "    \"Test there is a figure displayed in `ax`\"\n",
    "    assert ax and len(np.frombuffer(ax.figure.canvas.tostring_argb(), dtype=np.uint8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots()\n",
    "ax.imshow(array(im));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_fig_exists(ax)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Converted 00_test.ipynb.\n",
      "Converted 01_core.ipynb.\n",
      "Converted 01a_utils.ipynb.\n",
      "Converted 01b_dispatch.ipynb.\n",
      "Converted 01c_torch_core.ipynb.\n",
      "Converted 02_script.ipynb.\n",
      "Converted 03_dataloader.ipynb.\n",
      "Converted 04_transform.ipynb.\n",
      "Converted 05_data_core.ipynb.\n",
      "Converted 06_data_transforms.ipynb.\n",
      "Converted 07_vision_core.ipynb.\n",
      "Converted 08_pets_tutorial.ipynb.\n",
      "Converted 09_vision_augment.ipynb.\n",
      "Converted 10_data_block.ipynb.\n",
      "Converted 11_layers.ipynb.\n",
      "Converted 11a_vision_models_xresnet.ipynb.\n",
      "Converted 12_optimizer.ipynb.\n",
      "Converted 13_learner.ipynb.\n",
      "Converted 14_callback_schedule.ipynb.\n",
      "Converted 14a_callback_data.ipynb.\n",
      "Converted 15_callback_hook.ipynb.\n",
      "Converted 15a_vision_models_unet.ipynb.\n",
      "Converted 16_callback_progress.ipynb.\n",
      "Converted 17_callback_tracker.ipynb.\n",
      "Converted 18_callback_fp16.ipynb.\n",
      "Converted 19_callback_mixup.ipynb.\n",
      "Converted 20_metrics.ipynb.\n",
      "Converted 21_vision_learner.ipynb.\n",
      "Converted 22_tutorial_imagenette.ipynb.\n",
      "Converted 23_tutorial_transfer_learning.ipynb.\n",
      "Converted 30_text_core.ipynb.\n",
      "Converted 31_text_data.ipynb.\n",
      "Converted 32_text_models_awdlstm.ipynb.\n",
      "Converted 33_text_models_core.ipynb.\n",
      "Converted 34_callback_rnn.ipynb.\n",
      "Converted 35_tutorial_wikitext.ipynb.\n",
      "Converted 36_text_models_qrnn.ipynb.\n",
      "Converted 37_text_learner.ipynb.\n",
      "Converted 38_tutorial_ulmfit.ipynb.\n",
      "Converted 40_tabular_core.ipynb.\n",
      "Converted 41_tabular_model.ipynb.\n",
      "Converted 42_tabular_rapids.ipynb.\n",
      "Converted 50_data_block_examples.ipynb.\n",
      "Converted 60_medical_imaging.ipynb.\n",
      "Converted 65_medical_text.ipynb.\n",
      "Converted 90_notebook_core.ipynb.\n",
      "Converted 91_notebook_export.ipynb.\n",
      "Converted 92_notebook_showdoc.ipynb.\n",
      "Converted 93_notebook_export2html.ipynb.\n",
      "Converted 94_notebook_test.ipynb.\n",
      "Converted 95_index.ipynb.\n",
      "Converted 96_data_external.ipynb.\n",
      "Converted 97_utils_test.ipynb.\n",
      "Converted notebook2jekyll.ipynb.\n"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "from local.notebook.export import notebook2script\n",
    "notebook2script(all_fs=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}