I would say no; with the exception of dead code which a compiler can determine.

My definition of code coverage is a result which indicates how many times each line of code is run in your program: which, of course, means running the program. The determining factor here is usually the values of data passing through the program which the determine the paths of executions taken by conditionals. A static analysis, like a compiler, could deduce lines of code that cannot run under any conditions.

An example here is if your program uses a third-party library, but there is a bug in the library. If your program never uses those parts of the library, or the data you send to the library causes it to avoid the bug, then you won t be affected.

You could write a program that, by reflection, assumes that all conditionals will be taken, and follows all function calls, through all derived classes, but I m not sure what this will tell you. It certainly can t tell you whether or not there are any bugs in the lines of code covered.

See Static Estimation for Test Coverage for a technique that estimates coverage without executing the source code.

The basic idea is to compute a program slice for each test case, and then "count" what the slice enumerates. A (forward) slice is effectively that part of a program that you can reach from a specific starting point in the code, in this case, the test code.

While the technical paper above is hard to get if you re not an ACM member [or you didn t attend the conference where it was presented :], there s a slide presentation here.

Of course, running this static estimator only tells you (roughly) what code will be exercised. It doesn t substitute for actually running the tests, and verifying that they pass!

In general, the answer is no. This is equivalent to the halting problem, which is not computable.

There are (research) tools based on abstract interpretation or model checking that can show coverage properties without execution, for subsets of language. See, e.g.

"Analyzing Functional Coverage in Bounded Model Checking", Grosse, D. Kuhne, U. Drechsler, R. 2008

In general, yes, there are approaches, but they re specialized, and may require some formal methods experience. This kind of stuff is still cutting edge research.

Coverity Static Analysis is a tool that is can identify many secuirty flaws in a program. It can also identify dead code and can be used to help satisfy testing regulations such as D0178B which requires that the developers demonstrate that all code can be executed.

If you are using Visual Studio, you can first run Analyze Code Coverage , Then you can export code Coverage results using below Button(marked in Green) in Visual Studio:

Later you can import the Coverage Result file back to Visual Studio