Summary

SimCList is a rich, easy to use, fast, and dependable library for lists in C used primarily in embedded software and academia. After 2 years, I want SimCList to have a consistent regression test suite for enabling systematic quality assurance before going any further with it.

Are you a student, an open-source militant, or a Mister X who used and benefit from SimCList?

You can volunteer some hours of your time for a major contribution to the SimCList library: a consistent regression test suite.

This is the deal:

• give — you write a well-built regression test suite for the SimCList API
• get — you are recognized as key contributor in the home page and documentation of the library

Contact the author to apply.

The preliminaries:

• SimCList is well-designed, well-coded (neat and finely-commented) and well-documented.
• I provide precise guidelines on what to do, which guarantee to get effective work in short time.
• You have at least average experience with C.
• You get to know the SimCList API in four atomic steps: construction/destruction of lists and insertion/extraction/removal of items first, iteration second, comparator/meter/hasher/seeker functions third, and dumping/restoring of lists last.
  You can rely on the SimCList tutorial, the SimCList reference, and direct questions to the author for this purpose.

This is what you build:

0. (3 hours) a small library to generate random values for some data types (int, float, strings, structures, and arrays of them)
1. (4 hours) Tier1 set of test programs bullet proofing the core features:
   • declaration of an array of lists, interleaved creation, attribute setting, and destruction on them randomly.
     Stimulate functions: list_init(), list_destroy(), list_attributes_*().
   • declaration of an array of lists; lists will store items of different types; random interleaved insertion/deletion/extraction of items from them (checking correctness of extracted values by comparing with equivalent arrays).
     Stimulate functions: list_insert_at(), list_get_at(), list_delete_at(), list_size(), list_empty(), list_clear().
   • in one list, insertion of random elements, sorting, iteration, deletion.
     Stimulate functions: list_insert_at(), list_concat(), list_sort(), list_iterator_*(), list_delete_range(), list_get_max(), list_get_min().
2. (6 hours) Tier2 set of test programs bullet proofing user functions:
   • modification of one list, and checking that the same configuration returns the same hash. Stimulate functions: list_attributes_hash_computer(), list_insert_at(), list_delete_*(), list_hash().
   • create an array of lists, one per datatype, set a comparator function for each; insert random values in each; locate values in them; locate values in empty lists.
     Stimulate functions: list_attributes_comparator(), list_locate().
   • set meter function to enable insertion with autocopy; perform insertion of random pointers; check difference of original pointers with pointers in list (and that insertion of same pointer ends up in different pointers in list); delete elements from list, and check that elements have been freed. Tests: embedded meter functions, custom meter function for a custom data structure.
     Stimulate functions: list_attributes_copy(), list_insert_at(), list_extract_at(), list_clear().
   • define a complex data structure (contains multiple datatypes, and one sub-structure); insert random values; set seeker function to enable seeking, the seeker must compare with two fields in each element: one in the main structure, one in the sub-structure; insert random values; locate random elements; check outcome when locating non-existing elements; check outcome when inserting NULL values (seeker must deal with that).
     Stimulate functions: list_attributes_seeker(), list_seek().
3. (5 hours) Tier3 set of test programs bullet proofing extended features:
   • create an array of lists of several types; each datatype has two lists, where you insert the same random values; the first list of each pair is then dumped, cleared, and restored; assert (by hash comparison AND by element-by-element comparison) that the restored list is identical to the sister list. Stimulate functions: list_attributes_serializer(), list_attributes_unserializer(), list_dump_*(), list_restore_*().
   • create a list and insert random values in it; spawn a number of threads in the (user) program; from these threads, perform concurrently operations declared thread-safe for reading; occasionally let the threads enter mutual exclusion, modify the list, and release concurrent reads again.
     Stimulate functions: list_get_*(), list_empty(), list_locate(), list_seek().

Is it worth it? Reliability is priceless; SimCList took about 250 hours to develop so far; An estimated 40% of the overall cost of a software in its lifetime is up to testing; 18 hours is much less than 40% of 250 hours. It is important that the test suite is prepared by a person other than the author of the code to test.

You get:

• you make your part in Open Source Software; you forge your name as key contributor into the SimCList library.
• your work provides a precise, objective quality guarantee, making hundreds of users confident and happy.
• you unlock development of further features and improvements in SimCList.
• you will have direct support from the author for any usage of the library (including commercial products).
• you get preview access to newly developed functionalities of SimCList.

If you are a Computer Science student, this task is perfect for you. You can improve your proficiency in C and get involved in the Open Source community. At the same time, you can very reasonably propose this task to one of your professors as a course project, or for improving a grade you got. Projects with practically useful outcome are exceptionally rare and appreciated. In case the professor desires, I (research assistant at ETH Zurich) can provide feedback for grading.

If you already are a user of SimCList, you skip the API learning step, you improve your proficiency with the library, and you get direct support from the author.

If you are a random (Open Source?) developer, you can concentrate your work on one integer, measurable contribution, and be distinguished for it.