Crazy Developer

Whenever I'm asking a Quality Assurance Engineer "What is the best tool you dreamed?", I'm hearing the same answer:

That tool has to analyze itself the executables …deeply and thorougly all exisiting aspects and combinations …found the bugs and generate some reports for me …oops! I need the control – an easy scenario language, preferable UI-driven.

So I have been trying during my free time to write at least the base for such an instrument. It is BHR. Download it here tar-gzipped (~11MB).

So, what is the idea?

1. It is working both on Linux and Sun Solaris.

2. Using scenario XML files or command line you can target any executable(s) or library(ies), which was compiled sometimes by gcc and cc compilers. This set can be extended quite easily.

3. Using the ffcall library, BHR is extracting all the symbols from the executable (at least all the functions and not only).

4. If it is a C++ library, symbols are demangled and specific tips applied (for virtual functions or constructors, for instance).

5. Scenarios are executed step by step and results are compared with the required ones. Alternatively, all the combinations of possible scenarios are generated randomly and executed (some kind of stress-testing). An example of scenario used internally against my testing library:

<!DOCTYPE scenario [
<!ELEMENT scenario    (library,directive,execute,comment)>
<!ELEMENT library     (#PCDATA)>
<!ELEMENT directive   (#PCDATA)>
<!ATTLIST directive type CDATA #IMPLIED parameters CDATA #IMPLIED>
<!ELEMENT method (#PCDATA)>
<!ELEMENT comment (#PCDATA)>
]>

vh::get_string(char*)

    <method>
      <argument value="abcd"/>
      <argument value="2"/>
      <argument value="efgh"/>
      <result name="my_int1" type="int"/>
      <execute>
        <![CDATA[vh::nnn(std::string, int, std::string)]]>
      </execute>
    </method>
    

ml_get(long)

stub_plong

ml_set(void*)

ml_get(long&)

TestOne::string_static(char*)

vh::GetStructOne()

SetStructOne(StructOne)

TestOne::mc_one(char)

TestOne::mc_two(char)

TestOne::mc_three(const char)const

TestOne::mc_three(char) const

TestOne::mc_four(char&)

TestOne::msc_one(signed char)

TestOne::msc_two(signed char)

TestOne::muc_one(unsigned char)

TestOne::muc_two(unsigned char)

TestOne::mcs_one(const char*)

TestOne::mcs_one(char const*)

TestOne::mcs_two(const char*)

TestOne::mcs_two(char const*)

TestOne::mi_one(int)

TestOne::mi_two(int)

TestOne::mui_one(unsigned int)

TestOne::mui_two(unsigned int)

TestOne::mui_two(unsigned int)

TestOne::msh_one(short)

TestOne::msh_two(short)

TestOne::mush_one(unsigned short)

TestOne::mush_two(unsigned short)

TestOne::ml_one(long)

TestOne::ml_two(long)

TestOne::mul_one(unsigned long)

TestOne::mul_two(unsigned long)

TestOne::mll_one(long long)

TestOne::mll_two(long long)

TestOne::mull_one(unsigned long long)

TestOne::mull_two(unsigned long long)

TestOne::mf_one(float)

TestOne::mf_two(float)

TestOne::md_one(double)

TestOne::md_two(double)

	<method object="object1">
		<argument value="8436.989"/>
		<result type="void"/>
		<execute>
			<![CDATA[TestOne::mld_one(long double)]]>
		</execute>
	</method>
	<method object="object1">
		<argument value="678.05"/>
		<result name="double1" type="long double"/>
		<execute>
			<![CDATA[TestOne::mld_two(long double)]]>
		</execute>
	</method>
	

TestOne::mb_one(bool)

TestOne::mb_two(bool)

TestOne::get_string(char*, char*)

TestOne::~TestOne()

TestTwo::TestTwo(char*)

TestTwo::mc_one(char)

TestTwo::mc_two(char)

TestOne::md_two(double)