Local continuous integration system for C ++?

Question

"local continuous integration system" may not be the right term, but I hope to find a continuous integration system that can be configured to monitor changes in local files (in particular C ++ files) and 1) try to compile damaged object files (stop upon the first failure), and if successful, and without changing the new source file 2) to link the damaged binary files, and if it succeeds and there will be no changes in the new source file 3) run the tested tests.

By tracking changes to local files, I do not mean monitoring the monitor in the version control system, but the state of the local files as they are saved. Ideally, the system will provide integration with the original editors so that it can track changes in the editor that have not yet been saved to disk.

Ideally, this will also provide a graphical display (preferably in Windows 7) of the current and recent status, which allows you to quickly perform drilling in the event of a failure.

The closest I found was nose , as described here , but it covers only those Python tests that don't create files in C ++.

Answer 1

The closest thing to what you are looking for is cdash and boost booth ; I think that a tool like the one you are looking for will never exist for C ++, because compiling each project after editing a single file is just a waste of time in a C ++ productive workflow.

Answer 2

Continued Integration today is an upstream concept, so you are not alone here.

Assuming you work on Windows if you work with Microsoft Visual Studio
you can consider Microsoft Visual Studio Team Foundation Server (TFS)
(formerly Visual Studio Team System ).
This will give you Source-Control And Build-Automation in one package,
with great integration into Microsoft products, of course,
(I think there is a free version for MSDN users).

If you are not interested in Microsoft products or just looking for build automation,
I would recommend the great open source Continues Integration tool:
Jenkins CI .

Good luck

Answer 3

I would look at Jenkins CI - this is a good tool, works on any platform and can be configured on almost anything. I used it to run Python code that talked to a mobile phone, made calls and recorded these calls (and tested the “call quality”, although my project never got the full £ xxxx software because we just showed the concept), and then Jenkins will create graphs of “how well it worked.”

You can also do what you described as "chaining", so find that your source has changed, try to build it [usually this is done with make, so it automatically stops in the first file with an error (although it could be hundreds of errors in one file!)]. Compile and create success, then move on to running tests. Not quite sure how you define what is "important." If your test cycle is not huge, I would run them all!