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
