c# ean 13 barcode generator CROSS-REFERENCE in C#.NET

Encoder EAN13 in C#.NET CROSS-REFERENCE

This procedure is similar to the one for measuring complexity in How to Measure Complexity in Section 19.6.

Here s an example:

Statement1; Statement2; if ( x < 10 ) { Statement3; } Statement4;

In this instance, you start with one and count the if once to make a total of two. That means that you need to have at least two test cases to cover all the paths through the program. In this example, you d need to have the following test cases: Statements controlled by if are executed (x < 10). Statements controlled by if aren t executed (x >= 10).

The sample code needs to be a little more realistic to give you an accurate idea of how this kind of testing works. Realism in this case includes code containing defects.

The listing below is a slightly more complicated example. This piece of code is used throughout the chapter and contains a few possible errors.

1 2 3 4 5 6 7 // compute social security withholding, if below the maximum if ( m_employee[ id ].governmentRetirementWithheld < MAX_GOVT_RETIREMENT ) { // Compute Net Pay totalWithholdings = 0; for ( id = 0; id < numEmployees; id++ ) {

8 9 10 11 12 13 14 // determine discretionary employee retirement contribution if ( m_employee[ id ].WantsRetirement && EligibleForRetirement( m_employee[ id ] ) ) { companyRetirement = GetRetirement( m_employee[ id ] ); } grossPay = ComputeGrossPay ( m_employee[ id ] ); // determine IRA contribution personalRetirement = 0; if ( EligibleForPersonalRetirement( m_employee[ id ] ) ) { personalRetirement = PersonalRetirementContribution( m_employee[ id ], companyRetirement, grossPay ); } // make weekly paycheck withholding = ComputeWithholding( m_employee[ id ] ); netPay = grossPay - withholding - companyRetirement - governmentRetirement personalRetirement; PayEmployee( m_employee[ id ], netPay ); // add this employee's paycheck to total for accounting totalWithholdings = totalWithholdings + withholding; totalGovernmentRetirement = totalGovernmentRetirement + governmentRetirement; totalRetirement = totalRetirement + companyRetirement; 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 } 40 41 SavePayRecords( totalWithholdings, totalGovernmentRetirement, totalRetirement ); // set default to no retirement contribution companyRetirement = 0; } governmentRetirement = ComputeGovernmentRetirement( m_employee[ id ] );

6 Count 4 for the if and 5 for the &&.

In this example, you ll need one initial test case plus one for each of the five keywords, for a total of six. That doesn t mean that any six test cases will cover all the bases. It means that, at a minimum, six cases are required. Unless the cases are constructed carefully, they almost surely won t cover all the bases. The trick is to pay attention to the same keywords you used when counting the number of cases needed. Each keyword in the code represents something that can be either true or false; make sure you have at least one test case for each true and at least one for each false. Here is a set of test cases that covers all the bases in this example:

Test Data All boolean conditions are true numEmployees < 1 m_employee[ id ].governmentRetirementWithheld >=MAX_GOVT_RETIREMENT not m_employee[ id ]. WantsRetirement

The second if is false because the first part of the and is false The second if is false because the second part of the and is false The third if is false

not EligibleForRetirement( m_employee[id] )

not EligibleForPersonalRetirement( m_employee[ id ] )

If the routine were much more complicated than this, the number of test cases you d have to use just to cover all the paths would increase pretty quickly. Shorter routines tend to have fewer paths to test. Boolean expressions without a lot of ands and ors have fewer variations to test. Ease of testing is another good reason to keep your routines short and your boolean expressions simple. Now that you ve created six test cases for the routine and satisfied the demands of structured basis testing, can you consider the routine to be fully tested Probably not. This kind of testing assures you only that all of the code will be executed. It does not account for variations in data.