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
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.
What you give
- 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 is what you build:
- (3 hours) a small library to generate random values for some
data types (int, float, strings, structures, and arrays of them)
- (4 hours) Tier1 set of test programs bullet proofing the core
- declaration of an array of lists, interleaved creation,
attribute setting, and destruction on them randomly.
Stimulate functions: list_init(),
- 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
Stimulate functions: list_insert_at(),
- in one list, insertion of random elements,
sorting, iteration, deletion.
Stimulate functions: list_insert_at(),
- (6 hours) Tier2 set of test programs bullet proofing user
- modification of one list, and checking that the same
configuration returns the same hash. Stimulate functions:
- 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(),
- 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(),
- 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(),
- (5 hours) Tier3 set of test programs bullet proofing extended
- 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:
- 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_*(),
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.
What 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
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