python--unittest测试框架

unittest中最核心的四个概念是：test case, test suite, test runner, test fixture

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAg8AAAH5CAYAAAAGBt07AAAABHNCSVQICAgIfAhkiAAAAAFzUkdCAK7OHOkAAAAEZ0FNQQAAsY8L/GEFAAAACXBIWXMAAAsSAAALEgHS3X78AAArkUlEQVR4Xu3dDbAkVX0ocDUpBDU+U0oqfkSNMX4QgXt1HwFBliWAfGTly0UgQRJ41COijwdI+FKK2jwDArVr0PD4kEiMokLUZ0qU0lCWVYB8vYfrg5gnHwXK14aFBVZwQXbP69P39DIzzL27s7dvT5++v1/VqTt9Tk+fmT7/Of2fnp47LwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAeectb3vK/Jicn18a/qQoAaMK73/3usLGSVm3UsMcRS2p+0e///u9/IyYP8W+qAgCaMOwAPVjSqrV54xvf+D+32Wabu9PiUMMeRyypebNtSt8wLPYGS1q1KS9+9atf/V/f+c53/mT77bd/atttt31k1LNuztYBc6KpiXFT+qjWefnLX75bqqrFpvQNVZzMVNKqs7YpCe3v/M7vnDDbxzDsbJ1kGpi1jU1KxYF8j3e84x23FBPQM+9617t+XkxoJ6amF73pTW/6YnXfV7ziFQtT9X+K75BiXdH+j7GiWqe3lGsOqNqmSx567zvbvntvV2aq+63f+q33Fu8A/614B/ir1DTjviFv1bgPxkNdNmXbf/RHf/SzuM5rXvOa/1IsbrXFFlts8+Y3v/mKqdbNN5fPC5gnqolk2GRSHJR3mZiY+HXvOrH89m//9oeqVaoJLh5Ei+UXv/71r/90XC7q/19sjyv13rcqsX5Q1bYpyUNhVn333q7MVFckB/f2tm/CviFjvWOaqvpMlzgW7/C/Ge8T46VYfGmq+2qsq9799267KrF+UJGoPp3atp6q6TfsvoN10y33ltQkGQY23bBJpPLWt771+7G+eOdzTLG4ZTG5LIrLb3vb2340tcaLXvSyl73s3XGyifVbb731x+M782J5bVE/kVYpTddHr2qdwZKaX7CN2fQ9al0x8X+tWHz1VO2m7RvyVY17LKlqg5kSx6222uoNRRw+GZeLg+9/jzFaWL/ddts9UbS9Lt6/Wr+3lBseUBzIb45tRUzdsMUWW/xhqt5g2H0H66Zb7i2xXjIMjKR3okhVGxSTyZre9qoUE+HqtEqpmCT7PpstDuQfS00bVG1pcajebfSW1Dx0G5vb96h1W2655e+lqtKm7hvy1DumqWqDjSWOMQbj8rbbbruyWPeaePvVr371sbGtEutiSYtDxTMBRZw9F9eLSfFrX/vapUX1S6ZaNy2GN2WdSDIMjKSaSAYnkyi+W+pt7y1plVIxWR7X2/b617/+3NS0wbD7DdrYOsPaN7fvYnl9qitPLRe2mma9F9RFm7pvyNNM47kJieNL3v72t99U1RcH4OuLuhdPNU2p2tLitF7xilfsWmzr/1Trv+51rzsnNU0X1311m7JOJBkGRtI7UaSqDarTpq961av+vFjcaqq238te9rLt47uiuF7xzuh/pG2tK9659F23UExO5SnRrbbaasdU9QLpvi94HJXB9tn0Hd8Vxrr0jvBlv/u7v3tmuv9GJ9poU/YN+arGfdjYb0Li+OKYMFR122yzzb8XdVtMNU0ZWH+jijg9Iq4fLwhOVXEbG02AB5ejYXWSYWAkM00S8fPO3vYh68WLFv9frHvLW97yL7HiD/7gD74Xl9/1rnfdVyy+KtZF73znO//vNNvYYKa2aKB9Vn3Haxh664pt3dnbXhlWF23CviFjM43pxhLHrbfe+iOxvYi7nxaJw13xdpGcnpGaS5uSTBdx/c8xQS5ubvnKV75yz7h+kTz8x1TrpiXAg8vRsL4lw8BIqsllcIKpvOY1r/lvxYH1nmLCebaYrB7q/apY9XXJ2LbFFlu8LdYV7/rfVSyXn9P2rhsvyCom0tvjBY5xe6m6z0yPI+ptn23fxcT5hvg5b7H+L9/+9rf/7/g1uN7tV4bVVWbaN+StGvdhYz9T4ljE1euqd/FxvXgwjrfjNyde+tKXvrncQGGUZLq3FHH/+dT8ggQ4nuGobqdVhsbvsL4lwwAwSxs7gE6XOBYH9PKrmsU7+fLrw7EUt2+LddUZsmhTkuk3vOENF8avTMaP5uJXP4vlZUV1+RXkqDcBLvq4tUiA3zH4mAeXo+n6lgwDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAH3v3ud99c/dyu0o0yOTl5Uxreea/YH+I78yKeoYWGvViV/Esa3nlv2L5R8itpOIG2qF6cdIPJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWmo+T63TPtwv7oRrPNLzzXrU/yJN4hpaaj5PrdM+3C/uhGs80vPNetT/Ik3iGlpqPk+t0z7cL+6EazzS88161P8iTeIaWavPkev7554err746LU25+OKLw7Jlyza7LZru+Q7Wx+Ubb7wxHHDAAeF973tfOPXUU8OaNWtSaztV45mGd96r9gd5Es/QUm2eXNetWxfOOuuscP/995fLl1xySfjEJz4R1q9fv9lt0XTPd7A+Lp988snhwQcfDI8++mg46aSTwtlnn51a26kazzS88161P8iTeIaWavvk+swzz4TPfOYzZQJw3HHHhV//+tepZfPbpnu+g/VxOSYOlZiM7L333mmpnarxTMM771X7gzyJZ2ipHCbXlStXhl133TWsXr061Txvc9pi3eDHD0899VTYeeed09KUBQsWpFtT1q5dG3baaae01E4m2345xDfTE8/QUm2fXJ977rlw/PHHh6VLl5bXLMSPJCqb23b44YeX1zL0uvXWW8MRRxyRlqbE/fLEE0+kpRBuv/32sGTJkrTUTibbfm2Pb2YmnqGl2jy5xmsUzjzzzPICyOinP/3phmsONrct+sY3vhEOPPDAsGLFivCrX/2qbD/kkEPCN7/5zbTGlLhfPvnJT5ZnLuJHFkceeWS44oorUms7mWz7tTm+2TjxDC3V5sl1+fLl4XOf+1xamhIP8PFahs1ti2Jy8U//9E9lAvHHf/zHYfHixeHLX/5y2dYr7pevf/3rYdGiRWHhwoVlMtJ7BqONTLb92hzfbJx4hpYyuU4vx/1isu0nvvMmnqGlTK7Ty3G/mGz7ie+8iWdoKZPr9HLcLybbfuI7b+IZWsrk2i0m237iO2/iGVrK5NotJtt+4jtv4hlayuTaLSbbfuI7b+IZWsrk2i0m237iO2/iuUbFjry52qFKO8rk5ORNaXiyUz0HuqEazzS88574zpt4rlG1M5V2lTQ82akeP92QezzWTXznTTzXyIuhXXIPbvHULbnHY93Ed97Ec428GNol9+AWT92SezzWTXznTTzXyIuhXXIPbvHULbnHY93Ed97Ec428GNol9+AWT92SezzWTXznTTzXyIuhXXIPbvHULbnHY93Ed97Ec428GNol9+DuUjz95V/+ZTjqqKNmfTtnucdj3boU3+Nw9913h4svvjh88IMfTDXNEs818mJol9yDu0vxNJuEofd2znKPx7qNK74PPfTQdGt26trO5tpvv/3CmWeeObY5QjzXaFwvBobLPbjFU7fkHo91G1d819XnOB77MON6HNX4peFkNqqdSTvkHtziqVtyj8e6jSO+qz57+37mmWfC0qVLw8KFC8PRRx8dVq5cWdZHt912WzjssMPCrrvuGi699NJUO3w70Ve/+tWwePHisMsuu5QfKfS66qqrwj777BP23nvvcN1116Xa6fuY6XH16u2/SdVzT8PJbAwGEuOVe3CLp27JPR7rNq74HuzzoosuCqecckp48skny4P3GWeckVpCebC/9dZbw+OPPx6WL1+eaqcMbuc73/lOWLJkSbj99tvDE088ES644ILUMuWcc84JjzzySLj22mvDwQcfnGqn72Omx9VrHPswqsYvDSezUe1M2iH34BZP3ZJ7PNZtXPE92Of+++8fHnjggfL2mjVrwp577lnejvbaa6/yjMG6detSzfMGtxPPHqxYsSItvdBzzz0Xfvazn4Xvfve7YYcddki10/cx0+PqNY59GFXjl4aT2ah2Ju2Qe3CLp27JPR7rNq74Huxzxx133DA2sSxYsCC1hPKMQDyIxzMF8eOFXoPbee973xvWrl2blvp9//vfLw/+8eLfs846q+++0/Ux0+PqNfg4mlI9rjSczEa1M2mH3INbPHVL7vFYt3HF92Cf8VsLq1atSkshPPvss+nWlHhG4MorryyvVeg1uJ14rUM8szBMTBzuueee8nb8GGLwvsP62NjjqoxjH0ax31jScDIb1c6kHXIPbvHULbnHY93GFd+LFi0q3+HHawyiZcuWhdNOOy08+uij5TUJp556alkfnXfeeWH16tXhjjvueEHyMLidyy67LBx55JHl/1+IdXG7ld133z3cfPPN5ccP5557bt/znq6PmR5Xr3Hsw6gavzSczEa1M2mH3INbPHVL7vFYt3HFd3yHH7/ZsMcee5TLTz/9dPlRwm677Rb23Xff8oLGSkwI4rcdDjrooHDjjTem2imD24nXNMSLHOMFkLHuS1/6UlkfXX311WVdTCK+/e1v9z3v6fqY6XFF1f7rLU2q+kzDyWyMYwCZXu7BLZ66Jfd4rJv4zpt4rpEXQ7vkHtziqVtyj8e6ie+8iecaeTG0S+7BLZ66Jfd4rJv4zpt4rpEXQ7vkHtziqVtyj8e6ie+8iecaeTG0S+7BLZ66Jfd4rJv4zpt4rpEXQ7vkHtziqVtyj8e6ie+8iecaeTG0S+7B3aV4GvWnt6e7nbPc47FuXYrvcYj/mTL+LHj8z5bHHHNMuP/++1NLM8RzjbwY2iX34O5SPM0mYei9nbPc47Fu44rveMCtQ13b2Vwf+chHwp133ln+P4gLL7wwHHvssamlGeK5RuN6MTBc7sEtnrol93is27jiu64+x/HYe8Wf7K489dRTYeedd05LzajGLw0ns1HtTNoh9+AWT92SezzWbRzxXfXZ23c8CC9durT8L49HH310WLlyZVkfxX8/HX8tM/4nyfiz2JVh24m++tWvlr9xscsuu4SLL7441U6Jv5wZ//tk/BfU1113Xaqdvo+ZHteg+JHFn/7pn6alZlTPPQ0nszEYSIxX7sEtnrol93is27jie7DP+C+lTznllPIHq+LB+4wzzkgtoTzYx2sL4m9VLF++PNVOGdzOd77znbBkyZJw++23hyeeeCJccMEFqWXKOeecU/5GRfw30/EXNCvT9THT4xr0N3/zN+GSSy5JS82oxi8NJ7NR7UzaIffgFk/dkns81m1c8T3YZ/w57AceeKC8HX+4Kv4CZmWvvfYqzxjEX70cNLidePZgxYoVaemF4m9fxF/d/O53vxt22GGHVDt9HzM9rl7xvkccccS0v7o5V6rxS8PJbFQ7k3bIPbjFU7fkHo91G1d8D/a54447bhibWBYsWJBapr7REA/i8UxB/Hih1+B24rce1q5dm5b6ff/73y8P/vHi3/hjV733na6PmR5X5Vvf+lY48MADy1/ebFr1uNJwMhvVzqQdxh3cCxcu3LLo/7VpcWTiqVvGHY91mm1sR+OK78E+99tvv7Bq1aq0FF7wDj6eEYi/oDn4k9yD24nXOsQzC8PExOGee+4pb8ePIQbvO6yPjT2ueMbhgAMOCA8//HCqaVY1fmk4mY1qZ9IO4w7ubbfd9g1F/+snJyevK8oJ73nPe96YmjaJeOqWccdjnWYb29G44nvRokXlO/x4jUG0bNmycNppp5Xv3uM1CaeeempZH5133nlh9erV4Y477nhB8jC4nfjT2kceeWS4++67y7q43Ur8Ke6bb765/Pjh3HPP7Xve0/Ux0+P68pe/XJ6tGFfiEFXjl4aT2Wj6xdCV7yvPlXEHd5pgNzyOVG4uJttTivLWtNq0qvuMkxirTzWeaXizNtvYjqr7NS2+w4/fbNhjjz3K5fh/EuJHCbvttlvYd999ywsaKzEhiN92OOigg8KNN96YaqcMbide0xAvcowXQMa6L33pS2V9dPXVV5d1MYn49re/3fe8p+tjpscV7x8/xhgsTarGLw0ns1HtzKbU1VeTj7lJ1Xik4WncNBNsb/lxUT5ZTLbvTHfpU603TnX1P+7n0QbVeKbhzdpsYzuq1iVP1fil4WQ2mnwxVH319tmF7yvXqXpOaXgatwkTbG/5t6L8zcTExPbFXV8c71+1jUvVf+/jyDHGprtP06rnH8c2d7ON7ahqJ0/V+KXhZDaafjEM9tWF7yvXqRqP3Eoxyd5V/D2nWh6nwf5zjLGZHleTqvGcz6WK7eLvf67qyFM1funwx2w0/WIY7Cv37yvXrRqP3Mrk5OS/F+VT1fI4DfafY4zN9LiaVI3nfC49sf2eqo48VeOXDn/MRtMvhsG+cv6+8lyo+kvD07gRT+2uKMqZxTuybdLdW3Fad7D/HGNspsfVpOqxpeHN2mxjO6rayVM1fmk4mY2mXwyDfeX6feW5Uo1HGp7GbcIEe8t73vOeU4tJ9Q/TXfpU643TYP+5xth0j6tJ1Xim4c3abGM7qtYlT9X4peFkNpp+MXTh+8pzadzBPc0Ee/3k5OQJRXlTWm1a1X3GqQsxNtPjalI1nml4szbb2I6q+zG6G264ofwHUfGXNI855phw1113pZbmVOOXhpPZaPrFEN9JxSvIc/6+8lwad3CnCXZdMZn+oCgf3X777V+fmjZJ9fjHqQsxNtPjalI1nml4szbb2I6q/dG0LvzvkpNOOqm8xif+FPcXv/jF8uLjpnUpnsduXC8Ghht3cL/1rW996cTExNZpcWTiqVvGHY91mm1sR+OK77r6HMdjr8SvJldiAhG/7ty0avzScDIb1c6kHXIPbvHULbnHY93GEd9Vn7195/z/cR577LHwd3/3d+Hss89ONc2pnnsaTmZjMJAYr9yDWzx1S+7xWLdxxfdgnzn+75Ko2n/x57h/+ctfptrmVP2n4WQ2qp1JO+Qe3OKpW3KPx7qNK74H+4xf483x/+OsX78+PPTQQ+XFwaeffnqqbU41fmk4mY1qZ9IOuQe3eOqW3OOxbuOK78E+c///OPEbRq55yFy1M2mH3INbPHVL7vFYt3HF92CfOf7vkt7b8bqHePaiadX4peFkNqqdSTvkHtziqVtyj8e6jSu+u/C/S/76r/86PPzww2XiEK+F+PSnP51amiOeazSuFwPD5R7c4qlbco/Huo0rvrvwv0vixZl/8id/Um4zftMirts08Vyjcb0YGC734BZP3ZJ7PNZNfOdNPNfIi6Fdcg9u8dQtucdj3cR33sRzjbwY2iX34BZP3ZJ7PNZNfOdNPNfIi6Fdcg9u8dQtucdj3cR33sRzjbwY2iX34BZP3ZJ7PNZNfOdNPNfIi6Fdcg9u8dQtucdj3cR33sRzjbwY2iX34M49nuJ/0zvqqKPm7HZuco/HuuUe3/OdeK6RF0O75B7cucfTbBKDTbmdm9zjsW65x/d8J55r5MXQLrkHt3jqltzjsW7iO2/iuUZeDO2Se3CLp27JPR7rJr7zJp5r5MXQLrkHt3jqltzjsW7iO2/iuUZeDO2Se3CLp27JPR7rJr7zJp5r5MXQLrkHt3jqltzjsW7iO2/iuUZeDO2Se3CLp27JPR7rJr7zJp5r5MXQLrkHt3jqltzjsW65xfdsvlY86u0ciOca5fZi6Lrcg1s8dUvu8Vi33OJ7NsnAqLdzIJ5rlNuLoetyD27x1C25x2PdxHfexHONvBjaJffgFk/dkns81k18500818iLoV1yD27x1C25x2PdxHfexHONvBjaJffgFk/dkns81k18500818iLoV1yD27x1C25x2PdxHfexHONqp2ptKuk4clO9fjphtzjsW7iO2/iuUaTk5M3VTtUaU25IQ1PdqrnkKvZfFVtU27nphrPNLzzXu7xPd+JZ2ip3CfX2SQGm3I7NybbfrnH93wnnqGlTK7dYrLtJ77zJp6hpUyu3WKy7Se+8yaeoaVMrt1isu0nvvMmnqGlTK7dYrLtJ77zJp6hpUyu3WKy7Se+8yaeoaVMrt1isu0nvvMmnqGluja5Vs8nll133TUcc8wx4Zprrkmt3Vc99zS88161P8iTeIaW6trkWj2XdevWhQcffDD867/+a/jQhz4UPvGJT5R1XWey7de1+J5vxDO0VNcm12HP5bnnngvHHntsuPLKK1NNd5ls+3Utvucb8QwtNa7J9fzzzw9XX311Wppy8cUXh2XLlm12WzTdc/nJT34SDjvssLQ0lVBceOGFYZ999gm77757+NSnPhXWrl1btu2///7hrrvuKm9Hd955Z7nd+++/v1x+4IEHynWiWH/LLbeEQw45JOy0007hwx/+cLj77rvLtnGoxjMN77xX7Q/yJJ6hpcY1ucaPEM4666wNB+RLLrmk/Ghh/fr1m90WTfdcYmKw4447pqUQvvCFL5TXQzz00ENh1apV4fjjjw+f/exny7Zzzz13w+3oi1/8YvizP/uz8M1vfrNc/ta3vlWuE8X+TjzxxPCLX/wirFmzJpx99tnldselGs80vPNetT/Ik3iGlhrn5PrMM8+Ez3zmM2UCcNxxx4Vf//rXqWXz26Z7Lk899VTYZZdd0lIIBx54YHlGoXLvvfeGxYsXl7evu+66Dbejf/iHfyj7Ov3008vlM888M1x//fXl7dhfPBNReeyxx8LOO++clppXjWca3nmv2h/kSTxDS417cl25cmX5rYjVq1enmudtTtt0z+VHP/pROProo9NSKM9CxCSkEm/Hjx2i6izFj3/847BixYpw6623hnvuuSfsueeeZXtMPKr7DutvnPuzGs80vPNetT/Ik3iGlhrn5BqvO4gfFyxdurS8ZqH32xCb2zbsucQD/RFHHNH3lc14ZqH32oR45iEmBZWPfvSj4Zxzzik/sqg+ElmyZEn44Q9/GD72sY+Vy9Gw/sa1P6NqPNPwznvV/iBP4hlaalyTazwgx9P/8QLI6Kc//Wl5vUC0uW1R9Vzieo8//nj4wQ9+UF4oWV2jUIkXS8ZvYDz88MPh0UcfDSeccEK4/PLLU2sIX/nKV8L73//+8LWvfS3VTF2Y+Rd/8RdlW2XYvhvH/qxU45mGd96r9gd5Es/QUuOaXJcvXx4+97nPpaUp8YLEeC3D5rZF1fOJZeHCheGv/uqvygRiUDwbEROKPfbYI+y1117hggsuKM9oVO67775yG73XRcQzFbHu5z//eaqRPLRdtT/Ik3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWMrl2i8m2n/jOm3iGljK5dovJtp/4zpt4hpYyuXaLybaf+M6beIaWql6cSrdKGt55b9i+UfIraTiBtpicnLxp2ItVybrckIZ33hPfnSjiGQDqUh1g0yIAwMwkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwEgkDwDASCQPAMBIJA8AwLQWLFjwe0Wi8PmBUiYPA3Wfn5ycfF26GwAwXy1ZsuQ3isTgP4pSJQxDy8TExEPF6i+ZuhcAMK9NTk5eMixh6C3FOn+fVgcA5rsiOXj/YLIwpOyeVgcA5rttttlmiyI5WD2QLGwoExMTqxYuXPibaXUAgPKji8uHJQ6xFG2XptUAAKYUCcLiYYlDLEXb3mk1AIApCxcu3LJIFNYMJg4TExOPx4810moAAM8rkoUrBpOHovxjagYA6Dc5OXnwYPJQ1H0gNQMA9Ntuu+1ePjEx8XRP8rAmfpyRmgEAXqhIGP65J3n4SqoGABhuYmLisCp5KG5/MFUDAAy3ww47vLJKHuLHGKkaAGB6ReLwLxMTE99IiwAAMyuShyMnJyf/PC0CALNVHFxvrk7tK3mWIjm6KQ0nAMy9YQcjJb+ShhMA5l518CFPkgcAGid5yJvkAYDGSR7yJnkAoHGSh7xJHgBonOQhb5IHABonecib5AGAxkke8iZ5AKBxkoe8SR4AaJzkIW+SBwAaJ3nIm+QBgMZJHvImeQCgcZKHvEkeAGic5CFvkgcAGid5yJvkAYDGSR7yJnkAoHGSh7xJHgBonOQhb5IHABonecib5AGAxkke8iZ5AKBxkoe8SR4AaJzkIW+SBwAaJ3nIm+QBgMZJHvImeQCgcZKHvEkeAGic5CFvkgcAGid5yJvkAYDGSR7yJnkAoHGSh7xJHgBonOQhb5IHABo3V8lDtd1hpU692919993D6aefHh577LHU2n3Vc0/DCQBzrzr4zKU6t3/ooYemW1Oqba9fvz48/PDDZfLw8Y9/vKybD6rxS8MJAHOvOvjMpTq3P7itweXHH3887Lrrrmmp+6rxS8MJAHOvOvjMpWHbf+aZZ8LSpUvDwoULw9FHHx1WrlyZWkK47bbbwmGHHVYmAZdeemmqff5A2fuYB7d9//33h8WLF6el4X331sXbt9xySzjkkEPCTjvtFD784Q+Hu+++O7VuvH2m5xHve91115WPZ7fddku19Yp9xJKGEwDmXnXwmUvDtn/RRReFU045JTz55JNlgnDGGWeklhD22WefcOutt5ZnEZYvX55qpwxuq1qOH1vcd9994bjjjgvXXHNNWRcN67u3Lt4+8cQTwy9+8YuwZs2acPbZZ4djjjkmtW68fabnUd03fpzy6KOPptp6xT5iScMJAHOvOvjMpWHb33///cMDDzxQ3o4H5T333LO8He21117hqquuCuvWrUs1zxvcVvX4YznqqKPCnXfemVqmDOu7ty7erh5HFC+23HnnndPSxttneh7xvnfddVdamhuxj1jScALA3KsOPnNp2PZ33HHHDQe+WBYsWJBaQnnWIR6UDz744PIjjF6D26qWV6xYUX408L3vfa9crgyuH/XWzbZ9pucRl4clQHWq+k3DCQBzrzr4zKVh299vv/3CqlWr0lIIzz77bLo1JR50r7zyyrD33nunmimD2+pdjmcr4rUH8bqHyi677BJWr16dlkL5EULvfYY9tlHaZ3oew+5bt9hHLGk4AWDuVQefuTRs+8uWLQunnXZaeS3AI488Ek499dTUEsJ5551XHvDvuOOOFyQPixYtKs9GxOshot5tx4RjyZIl4fDDDy8vZIyOPfbY8Ld/+7flNQkxcTj55JP77jPssY3SPtPzGHbfusU+YknDCQBzrzr4zKVh23/66afDWWedVX7UsO+++4Zrr702tYRw2WWXlWcQDjrooHDjjTem2inxbET8FsYee+xRLg9u+/rrry/r4jcgonvvvbf8FkT8psQHPvCB8MMf/rDvPsMe2yjtMz2PYfetW+wjljScADD3qoMPeZI8ANA4yUPeJA8ANE7ykDfJAwCNkzzkTfIAQOMkD3mTPADQOMlD3iQPADRO8pA3yQMAjZM85E3yAEDjJA95kzwA0DjJQ94kDwA0TvKQN8kDAI2TPORN8gBA4yQPeZM8ANA4yUPeJA8ANE7ykDfJAwCNkzzkTfIAQOMkD3mTPADQOMlD3iQPADRO8pA3yQMAjZM85E3yAEDjJA95kzwA0DjJQ94kDwA0TvKQN8kDAI2TPORN8gBA4yQPeZM8ANA4yUPeJA8ANE7ykDfJAwCNkzzkTfIAQOMkD3mTPADQuOrgo+Rd0nACwNybnJy8adjBSMmq3JCGEwCYreoAmxYBAGYmeQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAEYieQAARiJ5AABGInkAAKa1YMGC3ysShc8PlDJ5GKj7/OTk5OvS3QCA+WrJkiW/USQG/1GUKmEYWiYmJh4qVn/J1L0AgHltcnLykmEJQ28p1vn7tDoAMN8VycH7B5OFIWX3tDoAMN9ts802WxTJweqBZGFDmZiYWLVw4cLfTKsDAJQfXVw+LHGIpWi7NK0GADClSBAWD0scYina9k6rAQBMWbhw4ZZForBmMHGYmJh4PH6skVYDAHhekSxcMZg8FOUfUzMAQL/JycmDB5OHou4DqRkAoN9222338omJiad7koc18eOM1AwA8EJFwvDPPcnDV1I1AMBwExMTh1XJQ3H7g6kaAGC4HXbY4ZVV8hA/xkjVAADTKxKHf5mYmPhGWgQAmFmRPBw5OTn552kRAJit4uB6c3VqX8mzFMnRTWk4AWDuDTsYKfmVNJwAMPeqgw95kjwA0DjJQ94kDwA0TvKQN8kDAI2TPORN8gBA4yQPeZM8ANA4yUPeJA8ANE7ykDfJAwCNkzzkTfIAQOMkD3mTPADQOMlD3iQPADRO8pA3yQMAjZM85E3yAEDjJA95kzwA0DjJQ94kDwA0TvKQN8kDAI2TPORN8gBA4yQPeZM8ANA4yUPeJA8ANE7ykDfJAwCNkzzkTfIAQOMkD3mTPADQOMlD3iQPADRO8pA3yQMAjZM85E3yAEDjJA95kzwA0DjJQ94kDwA0TvKQN8kDAI2TPORN8gBA4yQPeZM8ANA4yUPeJA8ANG6uk4dq+8NKnXq3u/vuu4fTTz89PPbYY6m1u6rnnIYTAOZedfBpQp39HHrooenWlGrb69evDw8//HCZPHz84x8v68Zl8DHOhWr80nACwNyrDj5NqLOfwW0NLj/++ONh1113TUvj0cR+jX3EkoYTAOZedfBpwrB+nnnmmbB06dKwcOHCcPTRR4eVK1emlhBuu+22cNhhh5VJwKWXXppqnz9g9j72wW3ff//9YfHixWlp5n7ifW+88cZwwAEHhPe9733h1FNPDWvWrEmtITz33HPhwgsvDPvss0/5kcinPvWpsHbt2tQ6df/rrruu7G+33XbbUNdb5kq1/TScADD35vrg1mtYPxdddFE45ZRTwpNPPlkmCGeccUZqCeXB+tZbby3PIixfvjzVThncVrUcP7a47777wnHHHReuueaasi6aqZ9435NPPjk8+OCD4dFHHw0nnXRSOPvss1NrCF/4whfCMcccEx566KGwatWqcPzxx4fPfvazqXXq/ieeeGL5cUm8f2XY861b7COWNJwAMPeqg08ThvWz//77hwceeKC8Hd/t77nnnuXtaK+99gpXXXVVWLduXap53uC2qucRy1FHHRXuvPPO1DJlpn7ifWLiUIlnLfbee++0FMKBBx7Yt717772376xGvP9dd92Vlp4X6+da9ZzTcALA3KsOPk0Y1s+OO+644QAYy4IFC1JLKM86xIP+wQcfXH6E0WtwW9XyihUryo8Ovve975XLlZn66b0dxY8kdtppp7Q0dd/4sUcl3u5tj9vblARnLlTPJw0nAMy96uDThGH97LfffuVHAZVnn3023ZoSD8pXXnll35mAaHBbvcvxbEW8tiGeQajM1E+87xNPPJGWQrj99tvDkiVL0lIozzLcfffdaWnqzEM8G1GZbv9NV1+n2EcsaTgBYO5VB58mDOtn2bJl4bTTTiuvFXjkkUfKixUr5513Xli9enW44447XpA8LFq0qDwbEa+HiHq3HROOePA//PDDN5wxmKmfeN9PfvKTZV8x4TjyyCPDFVdckVpDebHkscceu+GahhNOOCFcfvnlqXX6JGHwMc6F2HcsaTgBYO5VB58mDOvn6aefDmeddVb5UcO+++4brr322tQSwmWXXVaeQTjooIPKb0P0imcj4rcw9thjj3J5cNvXX399WRe/YRHN1E9c7+tf/3p5sI/9nX/++X0fQ8QE5Nxzzy37itdhXHDBBeU3MCrT7b/BxzgXYt+xpOEEgLlXHXzms5yfv+QBgMZJHiQPADASyYPkAQBGInnIm+QBgMZJHvImeQCgcZKHvEkeAGic5CFvkgcAGid5yJvkAYDGSR7yJnkAoHGSh7xJHgBonOQhb5IHABonecib5AGAxkke8iZ5AKBxkoe8SR4AaJzkIW+SBwAaJ3nIm+QBgMZJHvImeQCgcZKHvEkeAGic5CFvkgcAGid5yJvkAYDGSR7yJnkAoHGSh7xJHgBonOQhb5IHABonecib5AGAxkke8iZ5AKBxkoe8SR4AaJzkIW+SBwAaJ3nIm+QBgMZJHvImeQCgcZKHvEkeAGhcdfBR8i5pOAFg7k1OTt407GCkZFVuSMMJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAfPGiF/1/W2ooEBvLb3oAAAAASUVORK5CYII=" alt="" width="347" height="334" />

• 一个TestCase的实例就是一个测试用例。什么是测试用例呢？就是一个完整的测试流程，包括测试前准备环境的搭建(setUp)，执行测试代码(run)，以及测试后环境的还原(tearDown)。元测试(unit test)的本质也就在这里，一个测试用例是一个完整的测试单元，通过运行这个测试单元，可以对某一个问题进行验证。
• 而多个测试用例集合在一起，就是TestSuite，而且TestSuite也可以嵌套TestSuite。
• TestLoader是用来加载TestCase到TestSuite中的，其中有几个loadTestsFrom__()方法，就是从各个地方寻找TestCase，创建它们的实例，然后add到TestSuite中，再返回一个TestSuite实例。
• TextTestRunner是来执行测试用例的，其中的run(test)会执行TestSuite/TestCase中的run(result)方法。
  测试的结果会保存到TextTestResult实例中，包括运行了多少测试用例，成功了多少，失败了多少等信息。
• 而对一个测试用例环境的搭建和销毁，是一个fixture。

一个class继承了unittest.TestCase，便是一个测试用例，但如果其中有多个以 test 开头的方法，那么每有一个这样的方法，在load的时候便会生成一个TestCase实例，如：一个class中有四个test_xxx方法，最后在load到suite中时也有四个测试用例。

写好TestCase，然后由TestLoader加载TestCase到TestSuite，然后由TextTestRunner来运行TestSuite，运行的结果保存在TextTestResult中，我们通过命令行或者unittest.main()执行时，main会调用TextTestRunner中的run来执行，或者我们可以直接通过TextTestRunner来执行用例。这里加个说明，在Runner执行时，默认将执行结果输出到控制台，我们可以设置其输出到文件，在文件中查看结果（你可能听说过HTMLTestRunner，是的，通过它可以将结果输出到HTML中，生成漂亮的报告，它跟TextTestRunner是一样的，从名字就能看出来，这个我们后面再说）

用到TestSuite原因：1添加到TestSuite中的case是会按照添加的顺序执行的。2但如果有多个测试文件，怎么进行组织，总不能一个个文件执行吧，答案也在TestSuite中。TestSuite 相当于一个容器，用来装testcase

一：编写测试用例

编写自己的测试用例必须继承TestCase类:class xx(unittest.TestCase):

初始化测试环境：setUp和tearDown在每次执行case前后都执行了一次。

如果想要在所有case执行之前准备一次环境，并在所有case执行结束之后再清理环境，我们可以用 setUpClass() 与 tearDownClass():

        class TestMathFunc(unittest.TestCase):

        """Test mathfuc.py"""

        @classmethod

        def setUpClass(cls):

                print "This setUpClass() method only called once."

        @classmethod

        def tearDownClass(cls):

               print "This tearDownClass() method only called once too."

二：执行测试用例，
执行测试用例有两种方法：

1. 若是在测试用例所在的文件内执行用例，直接用 Unittest.main() 方法执行，main()方法会自动执行本文件中所有以test* 命名的函数，
2. 如果想将测试用例的文件和执行测试用例的文件分开来执行，需要以下顺序来写执行用例的代码：

A)导入模块：unittest，HTMLTestRunner(或TextTestRunner)，测试用例模块

B)：suite = unittest.TestSuite() 创建一个名字为suite 的容器，用来装testcase

C)：suite.addTest(TestMathFunc("test_multi"))   用addTest（）方法将case添加容器中 添加的是某一个测试用例

suite.addTests(unittest.TestLoader().loadTestsFromTestCase(TestMathFunc))  通过loadTestsFromTestCase()将case传入TestCase中，添加的是测试类中的所有用例，loadTestsFromModule(module):返回一个给定的模块中所有测试用例，
打包成一个套件返回。该类创建一个testsuites然后加载一个module并执行其中所有的测试用例，，执行的顺序是根据测试用例的名称来的: suite = unittest.TestLoader().loadTestsFromTestCase(WidgetTestCase)

D)：1） with open('UnittestTextReport.txt', 'a') as f:

        runner = unittest.TextTestRunner(stream=f, verbosity=2)

        通过TextTestRunner()方法来规定执行的测试用例结果输出到unittestTextReport.txt 文件中

    2） with open('HTMLReport.html', 'w') as f:

          runner = HTMLTestRunner(stream=f,

                       title='MathFunc Test Report',

                       description='generated by HTMLTestRunner.',

                       verbosity=2

                                )

 测试用例执行后的输出结果可以通过TextTestRunner()方法放到指定的txt文件中，或者通过HTMLTestRunner（）方法放到指定的html文件中，以网页形式展现，

E)：runner.run(suite) 执行用例

3)若在某个目录下写了很多Python文件，每个文件中都有测试测试用例，现在想让这个文件中的所以测试用例都自动执行，需要以下方法：

        import unittest,HTMLTestRunner

        suite = unittest.TestSuite()#创建测试套件

        all_cases = unittest.defaultTestLoader.discover('.','test_*.py')

        #找到某个目录下所有的以test开头的Python文件,

        for case in all_cases:

            suite.addTests(case)#把所有的测试用例添加进来

      fp = open('res.html','wb')

      runner = HTMLTestRunner.HTMLTestRunner(stream=fp,title='all_tests',description='所有测试情况')

      runner.run(suite)

      #运行测试

discover(start_dir, pattern='test*.py',top_level_dir=None)

递归查找指定目录（start_dir）及其子目录下的全部测试模块，将这些测试模块放入一个TestSuite 对象并返回。只有匹配pattern的测试文件才会被加载到TestSuite中。

如果一个测试文件的名称符合pattern，将检查该文件是否包含 load_tests() 函数，如果 load_tests() 函数存在，则由该函数负责加载本文件中的测试用例。如果不存在，就会执行loadTestsFromModule()，查找该文件中派生自TestCase 的类包含的 test 开头的方法。

    @unittest.skip("I don't want to run this case.")

    def test_divide(self):

        """Test method divide(a, b)"""

        print "divide"

        self.assertEqual(2, divide(6, 3))

        self.assertEqual(2.5, divide(5, 2))

@unittest.skip：此方法用来跳过某个testcase不去执行

Unittest 中的方法：1.检测元素是否相等：assertEqual(a,b [,msg]):检测a==b,这个方法检查a是否等于b，常用语检测元素属性等。assertNotEqual(a,b [,smg]):检测a!==b.

2. 检测表达式是否为Ture，或者 False: assertTrue(x [,msg]) assertFalse(x [,msg])

3. 逻辑运算
assertGreater(a, b) # 检测a > b.
assertGreaterEqual(a ,b) # 检测a >= b.
assertLess(a, b) #检测a < b.
assertLessEqual(a, b) #检测a <= b.=""
<="" code=""></=>