Anna University

CS6302 Object Oriented Analysis and Design

V-Sem-CSE 2017-Regulations
--------------------------------------------------------------------------------------------
Question Bank – 2 marks
--------------------------------------------------------------------------------------------
Question Bank
UNIT-V
1) What is an implementation model?
In UP terms, there exists an Implementation Model. This is all the implementation artifacts,
such as the source code, database definitions, JSP/XML/HTML pages, and so forth. Thus,
the code being created [using mapping design to code] chapter can be considered part of the
UP Implementation Model.

2) What are the steps involved in mapping design to code?

Mapping Designs to Code

Implementation in an object-oriented language requires writing source code for:

 class and interface definitions

 method definitions
3) Explain with an example of creating class definitions from DCDs.
Creating Class Definitions from DCDs

At the very least, DCDs depict the class or interface name, superclasses, operation signatures,
and attributes of a class. This is sufficient to create a basic class definition in an OO language. If
the DCD was drawn in a UML tool, it can generate the basic class definition from the diagrams.

Defining a Class with Method Signatures and Attributes

From the DCD, a mapping to the attribute definitions (Java fields) and method signatures for the
Java definition of SalesLineItem is straightforward, as shown in Figure below.

1
4) Explain in detail using an example how methods can be created from interaction
diagrams?
Creating Methods from Interaction Diagrams

The sequence of the messages in an interaction diagram translates to a series of statements in the
method definitions. The enterItem interaction diagram in Figure 20.2 illustrates the Java
definition of the enterItem method. For this example, we will explore the implementation of the
Register and its enterItem method. A Java

definition of the Register class is shown in Figure below.

2
 The enterItem message is sent to a Register instance; therefore, the enterItem method is
defined in class

Register.

public void enterItem(ItemID itemID, int qty)

Message 1: A getProductDescription message is sent to the ProductCatalog to retrieve a

ProductDescription.

ProductDescription desc = catalog.getProductDescription(itemID);

Message 2: The makeLineItem message is sent to the Sale.

currentSale.makeLineItem(desc, qty);

In summary, each sequenced message within a method, as shown on the interaction diagram, is
mapped to a statement in the Java method.

The complete enterItem method and its relationship to the interaction diagram is shown in Figure
20.4

3
5) What are collection classes? Give examples.
Collection Classes in Code

One-to-many relationships are common. For example, a Sale must maintain visibility to a group of
many SalesLineItem instances, as shown in Figure 20.5. In OO programming languages, these
relationships are usually implemented with the introduction of a collection object, such as a List or
Map, or even a simple array.

For example, the Java libraries contain collection classes such as ArrayList and HashMap, which
implement the List and Map interfaces, respectively. Using ArrayList, the Sale class can define
an attribute that maintains an ordered list of SalesLineItem instances.

4
 The choice of collection class is of course influenced by the requirements; key-based lookup
requires the use of a Map, a growing ordered list requires a List, and so on.

As a small point, note that the lineItems attribute is declared in terms of its interface.

Guideline: If an object implements an interface, declare the variable in terms of the

interface, not the concrete class.

For example, in Figure 20.5 the definition for the lineItems attribute demonstrates this
guideline:

private List lineItems = new ArrayList();

6) Wite short notes on a) Exception and error handling

Exception and error handling has been ignored in the beginning. The main focus was on
responsibility assignment and object design. But during implementation phase we need to
consider the large-scale exception handling strategies during design modeling.

The operation syntax allows to specify how exceptions are to be handles :

Example :

+ getPlayer( name : string ) : Player {exception IOException}

Public Player getplayer(string name_ throws exception

7) What is Test driven development?(TDD)

Test-Driven or Test-First Development

An excellent practice promoted by the Extreme Programming (XP) method [Beck00], and
applicable to the UP and other iterative methods (as most XP practices are), is test-driven
development (TDD) or test-first development. In this practice, unit testing code is written before
the code to be tested, and the developer writes unit testing code for all production code. The
basic rhythm is to write a little test code, then write a little production code, make it pass the test,
then write some more test code, and so forth.

8) Explain in detail a sample application for mapping design to code.

This section presents a sample domain layer of classes in Java for this iteration. The code generation
is largely derived from the design class diagrams and interaction diagrams defined in the design
work, based on the principles of mapping designs to code. The main point of this listing is to show
that there is a translation from design artifacts to a foundation of code. This code defines a simple
case; it is not meant to illustrate a robust, fully developed Java program with synchronization,
exception handling, and so on.

Comments excluded on purpose, in the interest of brevity, as the code is simple.

5
Class Payment

// all classes are probably in a package named

// something like:

package com.foo.nextgen.domain;

public class Payment

private Money amount;

public Payment( Money cashTendered ){ amount = cashTendered; }

public Money getAmount() { return amount; }

Class ProductCatalog

public class ProductCatalog

private Map<ItemID, ProductDescription>

descriptions = new HashMap()<ItemID, ProductDescription>;

public ProductCatalog()

// sample data

ItemID id1 = new ItemID( 100 );

ItemID id2 = new ItemID( 200 );

Money price = new Money( 3 );

ProductDescription desc;

desc = new ProductDescription( id1, price, "product 1" );

descriptions.put( id1, desc );

desc = new ProductDescription( id2, price, "product 2" );

6
descriptions.put( id2, desc );

public ProductDescription getProductDescription( ItemID id )

return descriptions.get( id );

Class Register

public class Register

private ProductCatalog catalog;

private Sale currentSale;

public Register( ProductCatalog catalog )

this.catalog = catalog;

public void endSale()

currentSale.becomeComplete();

public void enterItem( ItemID id, int quantity )

ProductDescription desc = catalog.getProductDescription( id );

currentSale.makeLineItem( desc, quantity );

7
public void makeNewSale()

currentSale = new Sale();

public void makePayment( Money cashTendered )

currentSale.makePayment( cashTendered );

Class ProductDescription

public class ProductDescription

private ItemID id;

private Money price;

private String description;

public ProductDescription

( ItemID id, Money price, String description )

this.id = id;

this.price = price;

this.description = description;

public ItemID getItemID() { return id; }

public Money getPrice() { return price; }

public String getDescription() { return description; }

8
}

Class Sale

public class Sale

private List<SalesLineItem> lineItems =

new ArrayList()<SalesLineItem>;

private Date date = new Date();

private boolean isComplete = false;

private Payment payment;

public Money getBalance()

return payment.getAmount().minus( getTotal() );

public void becomeComplete() { isComplete = true; }

public boolean isComplete() { return isComplete; }

public void makeLineItem

( ProductDescription desc, int quantity )

lineItems.add( new SalesLineItem( desc, quantity ) );

public Money getTotal()

Money total = new Money();

Money subtotal = null;

for ( SalesLineItem lineItem : lineItems )

9
{

subtotal = lineItem.getSubtotal();

total.add( subtotal );

return total;

public void makePayment( Money cashTendered )

payment = new Payment( cashTendered );

Class SalesLineItem

public class SalesLineItem

private int quantity;

private ProductDescription description;

public SalesLineItem (ProductDescription desc, int quantity )

this.description = desc;

this.quantity = quantity;

public Money getSubtotal()

return description.getPrice().times( quantity );

10
 }

Class Store

public class Store

private ProductCatalog catalog = new ProductCatalog();

private Register register = new Register( catalog );

public Register getRegister() { return register; }

9) What are the issues in OO Testing?

OO based on hope that objects could be reused without

 Modification
 Additional testing
 Based on notion that objects encapsulate functions and data that belong together
Consensus now is that such optimism is unwarranted
 OO programs has more severe testing problems than traditional programs
Complication of inheritance

 Unit is more difficult to define when inheritance is involved - Suggestion is to use the flat
definition
 Becomes complicated with multiple inheritance - Flattening solves inheritance problem
 Flattened classes are not a part of the system - Cannot be certain properly tested
Complication in Polymorphism

 Testing with different objects - Redundant tests on inherited methods

 Lose hoped for economies - Similarly testing polymorphism introduces redundant testing

10) What are the problems in OO testing due to Inheritance?

 Incorrect initialization of superclass attributes by the subclass

 Direct access to superclass fields from the subclass code
 Can create subtle side effects that break unsuspecting superclass methods
 A subclass violates an invariant from the superclass, or creates an invalid state
Complication of inheritance
 Unit is more difficult to define when inheritance is involved - Suggestion is to
use the flat definition
 Becomes complicated with multiple inheritance - Flattening solves inheritance
problem

11
  Flattened classes are not a part of the system - Cannot be certain properly tested
 May not have necessary methods for testing - Can add test methods
 Should they be a part of the delivered system?
 Analogous to having instrumented program text

11) Explain briefly units of OO Testing.

Individual methods are units

Levels of testing – 1
Four levels
 Method
 Unit testing
 Class
 Intraclass integration testing
 Integration
 Interclass integration testing
 System
 At port level – same as traditional testing

Levels of testing – 2
Classes are units
Three levels
 Class
 Unit testing
 Integration
 Interclass testing
 System
 At port level

12) What are the implications of composition and Encapsulation?

Composition (as opposed to decomposition) is the central design strategy in O-O Software
development. Together with the goal of reuse , composition creates the need for very stron unit
testing. Because a unit(class) may be composed with previously unknown other units , the
traditional notions of coupling and cohesion are applicable. Encapsulation has the potential to
resolve this concern, but only if the units (classes) are highly cohesive and very loosely coupled.
The main implication of composition is that , even presuming very good unit-level testing, the
real burden is at the integration testing level.
13) What are the implications of Inheritance in OO-Testing?

Eventhough , a class is considered as unit of testing as a natural choice, the role of Inheritance
complicates the matter. If a given class inherits attributes and/or operations from super classes , the stand
alone compilation criterion of a unit is sacrificed. However, the “flattened classes” concept alleviates
this problem. A flattened class is an original class expanded to include all the attributes and operations it
inherits.

12
Unit Testing on a flattened class solves the inheritance problem , but it raises another. A flattened class
will not be part of a final system, so some uncertainty remains. Also the methods in a flattened class
might not be sufficient to test the class. This leads to unending chain of methods testing other methods.

EXAMPLE

The LHS Fig. shows a UML inheritance diagram of a part of a simple automated teller machine. The fig.
on the RHS shows the “flattened” checkingAccount and savingsAccount classes. Here we need to test
the getbalance and setBalance operations twice resulting in losing some of the benefits of Object
Orientation.

14) What are the implications of Polymorphism on OO-Testing?

Testing with different objects introduces redundant tests on inherited methods

 Lose hoped for economies
 Similarly testing polymorphism introduces redundant testing

Polymorphism Issues are summarized as below :

 Repeatedly testing same methods
 Time can then be wasted if not addressed
 Potentially can be avoided, and actually save time

15) Briefly explain class testing.

Class Testing
 Class test cases are created by examining the specification of the class.
o This is more difficult if the class is a subclass and inherits data and behavior from a
super class. A complicated class hierarchy can be pose significant testing problems.
 If you have a state model for the class, test each transition - devise a driver that sets an object
of the class in the source state of the transition and generates the transition event.
 Class Constraints/Invariants should be incorporated into the class test.
13
 All class methods should be tested, but testing a method in isolation from the rest of the class is
usually meaningless
o Method Testing
 A public method in a class is typically tested using a black-box approach.
o Start from the specification, no need to look at the method body.
o Consider each parameter in the method signature, and identify its equivalence classes.
o Incorporate pre-conditions and post-conditions in your test of a method.
o Test exceptions.
 For complex logic, also use white-box testing or static testing.

16) What are the common guide lines for Units?

The common guidelines are that an Unit is :

(1) The smallest chunk that can be compiled by itself.
(2) A single procedure/function (Standalone)
(3) Something so small it would be developed by one person.

17) Discuss the merits and demerits of a) Methods as Units b) Classes as Units in OO unit
testing?
(a) Methods as Units.
A method implements a single function, and it would not be assigned to more than one
person, so methods might ideally be considered as units. The smallest compilation is
problematic.

(b) Classes as Units

Also if we are using fully flattened classes , we will need to unflatten them to their original form
when unit testing is complete.

Define Object Oriented Integration testing.

14
• Interclass Testing
• The first level of integration testing for object-oriented software
– Focus on interactions between classes
• Bottom-up integration according to “depends” relation
– A depends on B: Build and test B, then A
• Start from use/include hierarchy
– Implementation-level parallel to logical “depends” relation
• Class A makes method calls on class B
• Class A objects include references to class B methods
– but only if reference means “is part of”
18) Compare unit testing and Integration testing in OO Testing.
OO definitions of unit and integration testing
• Procedural software
– unit = single program, function, or procedure
more often: a unit of work that may correspond to one or more intertwined functions or
programs
• Object oriented software
– unit = class or (small) cluster of strongly related classes
(e.g., sets of Java classes that correspond to exceptions)
– unit testing = intra-class testing
– integration testing = inter-class testing (cluster of classes)
– dealing with single methods separately is usually too expensive (complex scaffolding), so
methods are usually tested in the context of the class they belong to
19) Explain in detail about OO Integration testing.

15
16
A sequence diagram traces ana execution-time path through a collaboraton diagram. Thick vertical lines
represent either a class or an instance of a class, and the arrows are labelled with the messsages sent by
(instances of) classes in their time order. The portion of oocalendar application that prints out the new
date is shown as sequence diagram as in Fig below :

17
20) What are MM-Paths for OO Software? Give an example.

An MM-Path in Object-Oriented Software is a sequence of method executions linked by

messages.

An MM-Path starts with a method and ends when it reaches a method that does not issue any
message of its own; this is the point of quiescence.

The figure below is an example of MM-Path for the collaboration diagram of OO Calendar
example shown above. With this formulation we can view object oriented integration testing
independently of whether the units were chosen as methods or classes.

18
19