BifurcumLib Files

What can You do with this Application?
=======================================
With this library you can get all paths needed for C1 coverage from a directional graph like UML or EPCs.

It's killer feature is that it sorts the branches lexicographically before deciding which branch to
run as first, second and so on. For what is this good for?

Imagine you have a comprehensive graph with two branches joining (lets call them "b1" and "b2")
and then splitting again in 55 branches.
You have 55 paths = 55 test cases at all. "b1" is easy to test, i.e. "read data from a file".
To test "b2" is a tedious work, i.e. "user has to type data in a external device" (and this task
can not done automated). Due the sort this library toggles "b1" for 54 test cases and "b2"
for 1 test case and you're done! I had such cases at my job - that is how this feature was born :-)

This library provides C1 coverage. It's algorithm is very simple (kind of DFS) and well documented
with use-cases (in the folder "doc"). The simple algorithm is intended because 12 years of
experience showed to me that every more sophisticated algorithm would only allow to draw technically
wrong graphs filling libraries with "enterprise knowledge" which is not so complete. If the paths
you get from your graph doesn't are as expected please ride through the graph with a pen first.

In difficult cases use the algorithm provided in the folder "doc". The author uses a iterative
technique of drawing a piece of the graph, getting the paths from it, check these paths 
(Did I really draw what I mean?), correct mistakes if necessary, drawing another piece and so on.
This is recommended because mistakes are found as soon when made and finding them is not that hard.

A graph which is technically wrong can not contain the intended information! Although a graph which
is technically correct may still not contain the intended information.
Thus you need to double-check:
(1) Is this graph technically correct?
(2) Does it contain the intended information?

Bifurcumlib is arranged in "traversing units". Each traversing unit implements one algorithm.

 1. TraversingUnitOne: A simple but efficient algorithm derived from depth-first search (DFS-) algorithm. It emulates the behaviour of an human being reading a directed graph.
 
	As a human would do it allows to determine the order to traverse branches. 

 2. TraversingUnitBfs: An implementation of the well-known breadth-first search (BFS-) algorithm used to print a adjacency table human-readable.
 

For more information about depth-first search algorithm see wikipedia [http://en.wikipedia.org/wiki/Depth-first_search].

For more information about breadth-first search algorithm see wikipedia [http://en.wikipedia.org/wiki/Breadth-first_search].

You may visit http://sourceforge.net/projects/bifurcumlib/ for updates and there is a blog too.

Java Version
=============
This project requires Java 8.


Dependencies
=============
Bifurcumlib does not depend on other libraries. 

Licence
========
This project is licensed under the MIT licence. For details see LICENSE.txt.

Known Problems
================
 - None so far.

Product Roadmap
================
 - No further plans so far.