You can omit modules with the --omit flag.  It takes a comma-separated list of path prefixes.  So for example:

    coverage run my_program.py
    coverage report --omit=path/to/3rdparty


In addition to the options in the other answers, you can also configure the ignored files via `setup.cfg`:

    [coverage:run]
    omit =
        some/directory/*
        debug_*.py

See the [documentation](https://coverage.readthedocs.io/en/latest/source.html#execution) for details.

Omitting some files worked for me using coverage API.
Well it is the same kind what Ned suggested.

Here it is how I did it:

`cov = coverage.coverage(omit=&#39;/usr/lib/python2.6/site-packages/*&#39;)`

Create a new file `.coveragerc` and add the following lines

```
[run]
branch = True
omit =
    directory/*
```

Say I have something like this:

    new File(&quot;test&quot;).eachFile() { file-&gt;  
    println file.getName()  
    }

This prints the full filename of every file in the `test` directory.  Is there a Groovy way to get the filename without any extension?  (Or am I back in regex land?)

Does groovy have an easy way to get a filename without the extension?

I&#39;m curious if its possible to create a custom event in jQuery that isn&#39;t bound to a DOM element.

I greatly prefer jQuery to YUI but there is one thing in YUI that I like, which is creating custom events and being able to subscribe to them later.

For example, this creates an event that is bound to a variable, not to a DOM element:

    var myevent = new YAHOO.util.CustomEvent(&quot;mycustomevent&quot;);

All of the examples and documentation I have been reading for jQuery require something like:

    $(&#39;body&#39;).bind(&#39;mycustomevent&#39;, function(){
        //do stuff
    });

Custom event in jQuery that isn&#39;t bound to a DOM element?

How do I exclude entire files from [coverage.py][1] reports?

According to the documentation you can exclude code by matching lines. I want to exclude entire files, so that the reports don&#39;t include 3rd party libraries. Am I missing something? Can it be done?


  [1]: http://nedbatchelder.com/code/coverage/

coverage.py: exclude files

<p>How do I exclude entire files from <a href="http://nedbatchelder.com/code/coverage/" target="_blank" rel="noopener noreferrer">coverage.py</a> reports?</p>
<p>According to the documentation you can exclude code by matching lines. I want to exclude entire files, so that the reports don't include 3rd party libraries. Am I missing something? Can it be done?</p>


In JavaScript, one can print out the definition of a function.  Is there a way to accomplish this in Python?  

(Just playing around in interactive mode, and I wanted to read a module without open().  I was just curious).  

Can Python print a function definition?

The following code works:

    class Foo(tuple):
    
        def __init__(self, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo([3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    play.py:4: DeprecationWarning: object.__init__() takes no parameters
      super(Foo, self).__init__(tuple(b))
    (3, 4)

But not the following:

    class Foo(tuple):
    
        def __init__(self, a, b):
            super(Foo, self).__init__(tuple(b))
    
    if __name__ == &#39;__main__&#39;:
        print Foo(None, [3, 4])
    
    $ python play.py 

Result:

&lt;!-- language: lang-none --&gt;

    Traceback (most recent call last):
      File &quot;play.py&quot;, line 7, in &lt;module&gt;
        print Foo(None, [3, 4])
    TypeError: tuple() takes at most 1 argument (2 given)

Why?




Subclassing tuple with multiple __init__ arguments

Does anyone know why Python&#39;s `list.append` function is not called `list.push` given that there&#39;s already a `list.pop` that removes and returns the last element (that indexed at -1) and `list.append` semantic is consistent with that use?

Why do python lists have pop() but not push()

I have a list of floats. If I simply `print` it, it shows up like this:

    [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]

I could use `print &quot;%.2f&quot;`, which would require a `for` loop to traverse the list, but then it wouldn&#39;t work for more complex data structures.
I&#39;d like something like (I&#39;m completely making this up)

    &gt;&gt;&gt; import print_options
    &gt;&gt;&gt; print_options.set_float_precision(2)
    &gt;&gt;&gt; print [9.0, 0.052999999999999999, 0.032575399999999997, 0.010892799999999999, 0.055702500000000002, 0.079330300000000006]
    [9.0, 0.05, 0.03, 0.01, 0.06, 0.08]

Easy pretty printing of floats?

Can I make `assert` throw an exception that I choose instead of `AssertionError`?

**UPDATE:**

I&#39;ll explain my motivation: Up to now, I&#39;ve had assertion-style tests that raised my own exceptions; For example, when you created a `Node` object with certain arguments, it would check if the arguments were good for creating a node, and if not it would raise `NodeError`.

But I know that Python has a `-o` mode in which asserts are skipped, which I would like to have available because it would make my program faster. But I would still like to have my own  exceptions. That&#39;s why I want to use assert with my own exceptions.

Making Python&#39;s `assert` throw an exception that I choose

I&#39;m attempting to use the new standard way of loading seed data in Rails 2.3.4+, the `db:seed` rake task.

I&#39;m loading constant data, which is required for my application to really function correctly.

What&#39;s the best way to get the `db:seed` task to run before the tests, so the data is pre-populated? 

How to load db:seed data into test database automatically?

I recently discussed with a colleague about mocking. He said that mocking classes is very bad and should not be done, only in few cases.

He says that only interfaces should be mocked, otherwise it&#39;s an architecture fault.

I wonder why this statement (I fully trust him) is so correct? I don&#39;t know it and would like to be convinced.

Did I miss the point of mocking (yes, I read [Martin Fowler&#39;s article][1])


  [1]: http://www.martinfowler.com/articles/mocksArentStubs.html

Why is it so bad to mock classes?

I&#39;m kind of a rookie with python unit testing, and particularly coverage.py.  Is it desirable to have coverage reports include the coverage of your actual test files?

Here&#39;s a screenshot of my [HTML report][1] as an example.

You can see that the report includes `tests/test_credit_card`.  At first I was trying to omit the `tests/` directory from the reports, like so:

    coverage html --omit=tests/ -d tests/coverage

I tried several variations of that command but I could *not* for the life of me get the tests/ excluded.  After accepting defeat, I began to wonder if maybe the test files are *supposed* to be included in the report.

Can anyone shed some light on this?  

  [1]: http://kylefox-awesome-stuff.s3.amazonaws.com/coverage.png

Is it possible exclude test directories from coverage.py reports?

When I look at the examples in the Assert class JavaDoc

    assertThat(&quot;Help! Integers don&#39;t work&quot;, 0, is(1)); // fails:
    // failure message:
    // Help! Integers don&#39;t work
    // expected: is &lt;1&gt; 
    // got value: &lt;0&gt;
    assertThat(&quot;Zero is one&quot;, 0, is(not(1))) // passes

I dont see a big advantage over, let&#39;s say, `assertEquals( 0, 1 )`.

It&#39;s nice maybe for the messages if the constructs get more complicated but do you see more advantages? Readability?



Why should I use Hamcrest-Matcher and assertThat() instead of traditional assertXXX()-Methods

I have a directory that contains my Python unit tests. Each unit test module is of the form **test_*.py**. I am attempting to make a file called **all_test.py** that will, you guessed it, run all files in the aforementioned test form and return the result. I have tried two methods so far; both have failed. I will show the two methods, and I hope someone out there knows how to actually do this correctly.

For my first valiant attempt, I thought &quot;If I just import all my testing modules in the file, and then call this `unittest.main()` doodad, it will work, right?&quot; Well, turns out I was wrong.

    import glob
    import unittest

    testSuite = unittest.TestSuite()
    test_file_strings = glob.glob(&#39;test_*.py&#39;)
    module_strings = [str[0:len(str)-3] for str in test_file_strings]

    if __name__ == &quot;__main__&quot;:
         unittest.main()

This did not work, the result I got was:

    $ python all_test.py 

    ----------------------------------------------------------------------
    Ran 0 tests in 0.000s

    OK

For my second try, I though, ok, maybe I will try to do this whole testing thing in a more &quot;manual&quot; fashion. So I attempted to do that below:

    import glob
    import unittest

    testSuite = unittest.TestSuite()
    test_file_strings = glob.glob(&#39;test_*.py&#39;)
    module_strings = [str[0:len(str)-3] for str in test_file_strings]
    [__import__(str) for str in module_strings]
    suites = [unittest.TestLoader().loadTestsFromName(str) for str in module_strings]
    [testSuite.addTest(suite) for suite in suites]
    print testSuite 

    result = unittest.TestResult()
    testSuite.run(result)
    print result

    #Ok, at this point I have a result
    #How do I display it as the normal unit test command line output?
    if __name__ == &quot;__main__&quot;:
        unittest.main()

This also did not work, but it seems so close!

    $ python all_test.py 
    &lt;unittest.TestSuite tests=[&lt;unittest.TestSuite tests=[&lt;unittest.TestSuite tests=[&lt;test_main.TestMain testMethod=test_respondes_to_get&gt;]&gt;]&gt;]&gt;
    &lt;unittest.TestResult run=1 errors=0 failures=0&gt;

    ----------------------------------------------------------------------
    Ran 0 tests in 0.000s

    OK

I seem to have a suite of some sort, and I can execute the result. I am a little concerned about the fact that it says I have only `run=1`, seems like that should be `run=2`, but it is progress. But how do I pass and display the result to main? Or how do I basically get it working so I can just run this file, and in doing so, run all the unit tests in this directory?

How do I run all Python unit tests in a directory?

Is there a way to see the code coverage when using nUnit? I know there&#39;s such a feature in Visual Studio, but can you use it with nUnit or only with the built-in vs unit tests?

Code coverage with nUnit?

How do code coverage tools like NCover know what parts of the code were executed and what parts were not?

How do code coverage tools work?

I&#39;m using gcov to measure coverage in my C++ code.  I&#39;d like to get to 100% coverage, but am hampered by the fact that there are some lines of code that are theoretically un-hittable (methods that are required to be implemented but which are never called, default branches of `switch` statements, etc.).  Each of these branches contains an `assert( false );` statement, but gcov still marks them as un-hit.

I&#39;d like to be able to tell gcov to ignore these branches.  Is there any way to give gcov that information -- by annotating the source code, or by any other mechanism?


How do I tell gcov to ignore un-hittable lines of C++ code?

This is the code:

    package com.XXX;
    public final class Foo {
      private Foo() {
        // intentionally empty
      }
      public static int bar() {
        return 1;
      }
    }

This is the test:

    package com.XXX;
    public FooTest {
      @Test 
      void testValidatesThatBarWorks() {
        int result = Foo.bar();
        assertEquals(1, result);
      }
      @Test(expected = java.lang.IllegalAccessException.class)
      void testValidatesThatClassFooIsNotInstantiable() {
        Class cls = Class.forName(&quot;com.XXX.Foo&quot;);
        cls.newInstance(); // exception here
      }
    }

Works fine, the class is tested. But Cobertura says that there is zero code coverage of the private constructor of the class. How can we add test coverage to such a private constructor?

How to add test coverage to a private constructor?

I can&#39;t seem to get code coverage with Nose to work, despite having the plugin installed.

Any ideas on how to fix this?

    12:15:25 ~/sandbox/ec$ nosetests --plugins
    Plugin xunit
    Plugin deprecated
    Plugin skip
    Plugin multiprocess
    Plugin failuredetail
    Plugin capture
    Plugin logcapture
    Plugin coverage
    Plugin attributeselector
    Plugin doctest
    Plugin profile
    Plugin id
    Plugin allmodules
    Plugin collect-only
    Plugin isolation
    Plugin pdb

    12:15:34 ~/sandbox/ec$ nosetests -v --with-coverage
    nose.plugins.cover: ERROR: Coverage not available: unable to import coverage module
    tests.edgecast_client_tests.test_log ... ok
    
    ----------------------------------------------------------------------
    Ran 1 test in 0.206s
    
    OK

How to Fix Python Nose: Coverage not available: unable to import coverage module

I have just started writing some unit tests for a python project I have using `unittest` and `coverage`. I&#39;m only currently testing a small proportion, but I am trying to work out the code coverage

I run my tests and get the coverage using the following

    python -m unittest discover -s tests/
    coverage run -m unittest discover -s tests/
    coverage report -m

The problem I&#39;m having is that `coverage` is telling I have 44% code coverage and is only counting the files that:

1. were tested in the unit tests (i.e., all the files that were not tested are missing and not in the overall coverage)
 
2. were in the libraries in the virtual environment and code coverage of the actual tests too. Surely it should not be including the actual tests in the results?

Furthermore, it says the files that are actually tested in these unit tests only have the first few lines tested (which are in most cases the import statements)

How do I get a more realistic code coverage or is this how it is meant to be?

How do I make coverage include not tested files?

I&#39;ve just started using [Coverage.py](http://coverage.readthedocs.org/en/latest/index.html) module and so decided to make a simple test to check how it works.

**Sample.py**

    def sum(num1, num2):
        return num1 + num2


    def sum_only_positive(num1, num2):
        if num1 &gt; 0 and num2 &gt; 0:
            return num1 + num2
        else:
            return None

**test.py**  

    from sample import sum, sum_only_positive

    def test_sum():
        assert sum(5, 5) == 10

    def test_sum_positive_ok():
        assert sum_only_positive(2, 2) == 4

    def test_sum_positive_fail():
        assert sum_only_positive(-1, 2) is None

As you see, all my code is covered with tests and py.test says all of them pass. I expect Coverage.py to show 100% coverage. Well, no.

[![Coverage.py results][1]][1]

Well, Coverage.py may not see test.py file, so I copied test functions to `sample.py` file and ran Coverage again:  
[![enter image description here][2]][2]

Then I added this block of code:

    if __name__ == &quot;__main__&quot;:
        print(sum(2, 4))
        print(sum_only_positive(2, 4))
        print(sum_only_positive(-1, 3))

and removed all test functions. After that, Coverage.py shows 100%:

[![enter image description here][3]][3]

Why is it so? Shouldn&#39;t Coverage.py show code test coverage, not just execution coverage? I&#39;ve read an official [F.A.Q.](http://coverage.readthedocs.org/en/latest/faq.html) for Coverage.py, but can&#39;t find the solution.  
Since many SO users are familiar with code testing and code coverage, I hope you can tell me, where am I mistaken.

*I have just one thought here: Coverage.py may simply watch which lines of code aren&#39;t executed so I should write tests for those lines. But there&#39;re lines which are executed already but aren&#39;t covered with tests so Coverage.py will fail here.*


  [1]: http://i.stack.imgur.com/bA2fO.png
  [2]: http://i.stack.imgur.com/ZM4dG.png
  [3]: http://i.stack.imgur.com/MmMqf.png

How to properly use coverage.py in Python?

I am trying to find the coverage using coverage module for a django project but gets 
```
Coverage.py warning: No data was collected. (no-data-collected)
```
My project folder has src and tests folders.

When I run 
```
coverage run -m pytest &amp;&amp; coverage report
```
It produces a report with 100% coverage with the list of files inside the tests folder.
Whereas when I run
```
coverage run --source=src -m pytest &amp;&amp; coverage report
```
it says 
```
Coverage.py warning: No data was collected. (no-data-collected)
No data to report.
```
When I try to give the `source=src` or `include=src` in the `.coveragerc` also the same warning occurs. The tests passes for all the above cases.

I want the coverage of the src folder.
Is it because I am missing some path setting?

Content Type	Original Author	Original Content on Stackoverflow
Question	flybywire	View Question on Stackoverflow
Solution 1 - Python	Ned Batchelder	View Answer on Stackoverflow
Solution 2 - Python	Florian Brucker	View Answer on Stackoverflow
Solution 3 - Python	Yogesh K	View Answer on Stackoverflow
Solution 4 - Python	muTheTechie	View Answer on Stackoverflow

coverage.py: exclude files

Python Problem Overview

Python Solutions

Solution 1 - Python

Solution 2 - Python

Solution 3 - Python

Solution 4 - Python

Custom event in jQuery that isn't bound to a DOM element?

Does groovy have an easy way to get a filename without the extension?

Attributions