Static code analysis can identify all linearly-independent paths and discover edge cases. Once these are identified, unit tests can be crafted from that analysis to exercise all of the independent paths and edge cases. This is essentially white box testing. Unit tests can be written manually, or they can be code-generated.
It's highly likely that such analysis takes place, not at the source-code level, but probably at the level of the AST (abstract syntax tree) in the compiler, or at the byte-code/intermediate language level (where adequate metadata exists to support the analysis).
When I hear the phrase "whether this can be used on a higher level, e.g. general flow of an application," I think of integration tests, not unit tests.
How your application's components integrate is largely a matter of the software architecture that you choose. In a good architecture, these tests are, shall we say, "uninteresting," in the sense that they don't really test actual functionality, but merely confirm that you've connected your working components together properly.
Above this level you enter the domain of acceptance tests. Acceptance tests are generally devised against functional requirements, and wouldn't benefit much from path analysis, in my opinion. Your difficulties there arise from the inherent brittleness of automating such tests. Again, a good architecture would lean more heavily on verification via unit tests.
Generate unit tests for your code with IntelliTest
IntelliTest explores your code to generate test data and a suite of unit tests. For every statement in the code, a test input is generated that will execute that statement. A case analysis is performed for every conditional branch in the code. For example,
if statements, assertions, and all operations that can throw exceptions are analyzed. This analysis is used to generate test data for a parameterized unit test for each of your methods, creating unit tests with high code coverage.
In short, sure, you could do all of this by hand, but a machine can do it better, faster, more thoroughly and with fewer errors.