STUDENT NAME: FAISAL

STUDENT ID: 1053009201402000004

Question:
16.8. Besides counting errors and defects, are there other countable characteristics of software
that imply quality? What are they and can they be measured directly?

Answer:
Countable characteristics of software that imply quality (beside errors):
Any countable measure that indicates the factors noted in Chapter 16 are candidates. For example,
maintainability as measured by mean-time-to-change; portability as measured by an index that
indicates conformance to language standard; complexity as measured by McCabe's metric, availability,
reliability, and so on.

The full table of Characteristics and Sub characteristics for the ISO 9126-1 Quality
Model is:Characteristics Sub characteristics

Functionality

Definitions

Suitability

This is the essential Functionality characteristic and

refers to the appropriateness (to specification) of the
functions of the software.

Accurateness

This refers to the correctness of the functions; an ATM

may provide a cash dispensing function but is the
amount correct?

Interoperability

A given software component or system does not typically

function in isolation. This sub characteristic concerns the
ability of a software component to interact with other
components or systems.

Compliance

Where appropriate certain industry (or government)

laws and guidelines need to be complied with, i.e. SOX.
This sub characteristic addresses the compliant capability
of software.

Security

This sub characteristic relates to unauthorized access to

the software functions.

Reliability

Maturity

This sub characteristic concerns frequency of failure of

the software.

Fault tolerance

The ability of software to withstand (and recover) from

component, or environmental, failure.

Recoverability

Ability to bring back a failed system to full operation,

including data and network connections.

Determines the ease of which the systems functions can

Understandability be understood, relates to user mental models in Human
Computer Interaction methods.
Usability

Efficiency

Learnability

Learning effort for different users, i.e. novice, expert,

casual etc.

Operability

Ability of the software to be easily operated by a given

user in a given environment.

Time behavior

Characterizes response times for a given thru put, i.e.

transaction rate.

Resource
behavior

Characterizes resources used, i.e. memory, cpu, disk and

network usage.

Analyzability

Characterizes the ability to identify the root cause of a

failure within the software.

Maintainability Changeability

Portability

Characterizes the amount of effort to change a system.

Stability

Characterizes the sensitivity to change of a given system

that is the negative impact that may be caused by
system changes.

Testability

Characterizes the effort needed to verify (test) a system

change.

Adaptability

Characterizes the ability of the system to change to new

specifications or operating environments.

Installability

Characterizes the effort required to install the software.

Conformance

Similar to compliance for functionality, but this

characteristic relates to portability. One example would
be Open SQL conformance which relates to portability of
database used.

Replaceability

Characterizes the plug and play aspect of software

components, that is how easy is it to exchange a given

software component within a specified environment.

Question:
Myers [Mye79] uses the following program as a self-assessment for your ability to specify adequate
testing: A program reads three integer values. The three values are interpreted as representing the
lengths of the sides of a triangle. The program prints a message that states whether the triangle is
scalene, isosceles, or equilateral. Develop a set of test cases that you feel will adequately test this
program.

Answer:
The program reads three integer values. The three values are interpreted as representing the
lengths of the sides of a triangle. The program prints a message that states whether the triangle is
scalene, isosceles, or equilateral. Write test cases (specific input values) that you feel would
adequately test this program.

In a valid triangle, no side may have a length of zero or less, and each side
must be shorter than the sum of all sides divided by 2.
Equilateral triangle: all sides are of equal length.
Isosceles triangle: two sides are of equal length.
Scalene triangle: all sides are of unequal length.

In mathematics, the number of integer values is infinite. However, computers have finite space which
limits the number of values that can be processed. Let us assume that our triangle program is running
in a tiny computer with 10.000 as the largest integer value. Then there are 104* 104* 104= 1012
possible length combinations of triangle sides (including the invalid ones).
Suppose you are a very fast tester, running and checking 1000 tests per second, 24 hours per day,
365 days per year.
Then the exhaustive testing effort (testing each possible length combination) would take over 31.7
years.

Some of Possible Test Cases [1]

1. (5, 3, 4): scalene

1. (2, 5, 8): invalid (Too long, perm.)

2. (3, 3, 4): isosceles

2. (2, 8, 5): invalid (Too long, perm.)

3. (3, 3, 3): equilateral

3. (8, 5, 2): invalid (Too long, perm.)

4. (50, 50, 25): isosceles

4. (5, 8, 2): invalid (Too long, perm.)

5. (25, 50, 50): isosceles (permutation)

5. (5, 2, 8): invalid (Too long, perm.)

6. (50, 25, 50): isosceles (permutation)

6. (0, 0, 0): invalid (all zeros)

7. (10, 10, 0): invalid (zero)

7. (@, 4, 5): invalid (non-integer)

8. (3, 3, -4): invalid (negative)

8. (3, $, 5): invalid (non-integer)

9. (5, 5, 10): invalid (too long)

9. (3, 4, %): invalid (non-integer)

10. (10, 5, 5): invalid (too long, perm.)

10. (, 4, 5): invalid (missing input)

11. (5, 10, 5): invalid (too long, perm.)

11. (3,,5): invalid (missing input)

12. (8, 2, 5): invalid (Too long)

12. (3, 4,): invalid (missing input)

Some Remarks:
Most test cases represent invalid inputs
Each valid triangle type is tested at least once
Permutations are used to check that the order of the input values does not affect the result
Boundary input values are used (length of exactly zero, length of exactly the sum of all sides divided
by 2)
Input values of wrong type (non-integers) are used
The number of test cases is rather small with respect to the number of all possible inputs