Wood J. Object-Oriented Programming with ABAP Objects

Подождите немного. Документ загружается.

Creating Exception Classes

GUAGE,

and click the DISPLAY button (see Figure 8.11). Figure 8.12 shows the

CHANGE CONCEPT screen of the OTR for the selected OTR key.

B-

Cootepi Edit Ooco Wrt*iiM) S^tem Help

3 vJ O0© J . V:

00 <3(1

OTR: Maintain Initial Screen

|90 fmd

T««1

Typo

®Short Ted

OLOngTM

Te»l 7

Language

iFEZ TJ

Ted

•

Concept

EJ06B833«f05154?E100000>»Al1447e

Display Q Create ; ^ Change

Figure 8.11 Looking up Texts in the OTR — Part 1

Figure 8.12 Looking up Texts in the OTR — Part 2

225

8 | Error Handling with Exceptions

You can define text parameters in your exception texts by surrounding elemen-

tary attribute names between ampersands. For example, the exception text

REA0_ERR0R from exception class CX_SY_FILE_IO shown in Figure 8.9 contains

three text parameters: &FILENAME&. &ERR0RC0DE&, and &ERRORTEXT&. At runtime,

method GET_TEXT, which is defined in interface IF_MESSAGE and whose imple-

mentation is inherited through class CX_R00T, will replace these text parameter

tags with the values of the corresponding instance attributes defined in class

CX_SY_F

LE_10 to produce a message text that is more meaningful to the end user.

For exception classes to be able to support message parameters, there must be a

way to pass data to the exception object. However, if you recall from Section

8.5.3, Global Exception Classes, you are not allowed to edit the constructor of a

global class. In spite of this, it is possible to supplement the interface of the con-

structor by defining public instance attributes. The Class Builder will add import-

ing parameters using the same name and typing information used to define the

attribute. In addition, it will also augment the implementation of the constructor

method to include assignment statements to store the importing parameter

within the corresponding attribute. This allows you to create an exception object

with all of the relevant parameters needed to accurately define the exception sit-

uation.

For example, the code in Listing 8.15 shows how an exception of type

CX_SY_FILE_I0 can be raised whenever a read error occurs. In this case, the

optional FILENAME parameter was used to indicate the name of the file that could

not be read.

DATA: 1r_ex TYPE REF TO cx_sy_fi1e_io.

lv_msg TYPE string.

TRY.

RAISE EXCPETION TYPE cx_sy_fi1e_io

EXPORTING

text id - cx_sy_file_io->read_error

filename - 'somefile.txt'.

CATCH cx_sy_fi1e_io INTO lr_ex.

lv_msg - lr_ex->get_text( ).

MESSAGE

v_msg TYPE T.

ENDTRY.

Listing 8.15 Retrieving Explanatory Text from Exception Instances

226

Creating Exception Classes

8.5.5 Mapping Exception Texts to Message IDs

Beginning with the release 6.40 of the SAP NetWeaver Application Server, you

can now map exception texts to message IDs within a message class. You can

enable this functionality

your exception classes by choosing the WITH MESSAGE

CLASS option in the CREATE CLASS dialog box (asyou've already

seen

in Figure 8.7).

To demonstrate how to map exception texts to message IDs, let's consider an

example of an exception class called ZCX_USER_CREATE_FAI LEO that is used to han-

dle exceptions related to the creation of users in a custom user management API.

1. To provide information about the user in question, a public instance attribute

called USER_NAME has been provided that will be added to the parameter inter-

face of the CONSTRUCTOR method (see Figure 8.13).

Class interface 2CX_USER_CR€ATE_FAIIE0 implemented/mac ttve

Properties interfaces Fnends mi- imcs 1 Teas Metnods Events Types Aliases

Eflra Misers i si cam

• filter

|Aar.&uee |Levei Ivisi |Re Imping |AssooatedType

Description initial value

IF_TtOO_HESSA6E-OEFAlCo«iStanPuWic

I F_T 100_N£SSA6E-T

MHnstanctPuMK Type SCX_T160KEY

T100 Key wrtti Parameters

CX.ROOT ConstanPubiK Type SOTR.COMC

Excepfcon© value fw Afirri6AA9A3937

TEXTIO instancePubiic F Type

SOTR.COMC

Key for Access io Message

PREVIOUS instancePubix F Type fief

CX_ROOT

<•

Exception Mapped to the C

KERKEl.ERfilO instancePubtx F Type

S380ERftIC- O

internal Nam® of EwepOor

C0_0UPL

CATE_0SER ConsianPubhc T Type SOTR_COKC

tfSER_NAHE| instancePubW • Type SYUHAHE

Jser Name

• Type

Figure 8.13 Defining Parameters in ZCX_USER_CREATE_FAILED

2. If you look carefully on the INTERFACES tab of the Exception Builder, you will

notice that this exception class is implementing interface IF_T100_MESSAGE.

IF_T100_MESSAGE is a nested interface that embeds the I F_MESSAGE interface

that you have normally

seen

used with exception classes. The I F_TI00_HESSAGE

interface also defines some attributes that support the mapping of exception

texts to message IDs. These details are encapsulated inside the implementations

of methods IF_MESSAGE~GET_TEXT and IF_MESSAGE~GET_LONGTEXT in the root

exception class CX_R00T.

3. To map an exception text to a message ID, you can simply create a new excep-

tion text and click on the MESSAGE TEXT button in the toolbar above the excep-

tion text input table. This will bring up the ASSIGN ATTRIBUTES OF AN EXCEPTION

22 7

Error Handling with Exceptions

CLASS TO A MESSAGE dialog box shown in Figure 8.14. Here, we are assigning

message ID 088 from message class 01 to the exception text

CO_OUPLLCATE_USER.

Class »err>:s

ZCX_UM*_CRCATt_rAIl.£P

Ma'.'-'-?I,-!!! WT'.tmi '1/.T.W1 TMJ

H^ls«n*nMd/lnac»»e

Meffioas | e»wi» | Types , Aliases

[EneptOnC

ZCl.VUK.C

jjflj LonoJ

ZCX_LLS£R_CFT£ATE_FAIL.£0

CO_K*UCATE_US£R

JI2L

"Ol-.WTrt I

lir-Atfgn e< an E«e»on Class

Metsaje Q /

Message Cuss It! ~1

Message Njrrter 088

Message Ted Message Ted usei

easts

ajmhws Sx E««oon Class /

Aa-e.

"Ol

Alt'® 3

KERNEL.EWO

AO-e 4

I BU

I I

lEEEllal

Figure 8.14 Mapping a Message ID to an Exception Text

4. Figure 8.15 shows this message as defined in message maintenance Transaction

SE91. As you can see. you also have the option to map elementaiy attributes

from the

ZCX_USER_CREATE_FAILED

class to the message parameters.

re-

Message class Edit Goto UMittestM) Enyorenent System Help

e - <j o 00e QM ki aoaa DCT ®a

Message Maintenance: Display Message (Compressed)

JJ Selected entries («§) tfjjg)

Message class |W ] A»B»

•.'..•llfflfir Messages

1 f.y.i i' i]ff??n?Tg??i

CEHSI

m I I • l l I I laapei I I

iMessagejMessage short te»i

C*ci*al foreat 4 is invalid (Hot ", I or t)

Creation started of user m central systee

lse*e»pianary D

r a

Profile assignment for user t eas deleted

Role assignient to user l deleted

Figure 8.15 Displaying a Message in Message Maintenance

228

UML Tutorial: Activity Diagrams

The primary benefit for using the message mapping option with your exception

classes is that you can leverage a pre-existing message base that is being main-

tained across the development landscape. Such messages can be maintained with

long text and translated into other languages using the familiar tools provided in

Transaction SE91.

Another advantage of using the message mapping option is the fact that the MES-

SAGE statement in ABAP now provides direct support for exception classes that

implement the IF_T100_MESSAGE interface; this functionality was introduced with

the SAP NetWeaver 2004 release. The code snippet in Listing 8.16 shows how the

MESSAGE statement can be used to output an exception text to the screen. In the

past, we would have had to extract the message text into a string variable using

the GET_TEXT method before we could display it using the MESSAGE statement.

TRY.

CATCH cx_some_exception INTO lr_ex.

MESSAGE lr_ex TYPE 'E\

ENDTRY.

Listing 8.16 Displaying Exception Texts with the MESSAGE Statement

8.6 UAAL Tutorial: Activity Diagrams

The UML activity diagram is a behavioral diagram used to depict the high level

flow within a module or program. Activity diagrams are quite similar in nature to

flowcharts. However,

you will see. there are certain things you can do with an

activity diagram that you cannot do with a flowchart.

Figure 8.16 shows an example of an activity diagram that is being used to depict

the flow of a simple ABAP extract program. The flow begins at the initial node

action and proceeds to the very first action called Receive Queiy Parameters.

Notice that the action names used here are fairly generic. For example, in the

ABAP extract program, the Receive Queiy Parameters action would encompass

the generation of a selection screen and the entiy of selection parameters by a

user. You can trace the control flow of an activity diagram by following the

directed edges between actions. Eventually, the program flow will proceed all the

way down to the Activity Final action.

229

8 | Error Handling with Exceptions

One significant addition to activity diagrams in the UML 2.0 standard was the

specification of protected nodes and handler blocks. As you can see in Figure 8.16,

the action Extract Data from Database is a protected node that might trigger an

exception (i.e., Selection Failed). If no data is found in the database for the

given selection criteria, control is transferred to the Display "No Data Found"

Message handler block. It is also possible to group together multiple actions

inside of a protected node. For example, all of the file I/O actions in Figure 8.16

were grouped together in a protected node that reacts to file I/O exceptions.

In the diagram shown in Figure 8.16, notice that flow from each handler block

leads into a diamond-shaped node called a merge. Merges provide a convenient

way of channeling multiple input flows into a common output flow.

230

Summary

If you look carefully at the Write Record to File action in Figure 8.16, you will

notice that its boundaiy is depicted using a dotted line in lieu of the solid line

used with all of the other normal actions. This dotted line marks an expansion

region in the activity diagram. In the flow from Figure 8.16, the Write Record to

File expansion region (along with the inputting tokens shown as small pins along

the top of the action) represents a loop that takes the extract records from the

database lookup and iteratively writes them to the extract file. This kind of nota-

tion is much more elegant than the typical use of conditionals in flowcharts to

determine if there are more records to process, and so on.

One of the beauties of activity diagrams is that they are extremely easy to read,

often requiring little to no translation for nontechnical members of the team.

Consequently, they are an excellent communication tool for describing and refin-

ing a program flow with functional team members. Typically, after the process

flow within an activity diagram is agreed upon, the design can be put in more

technical terms in the form of interaction diagrams such as a sequence diagram,

and so on. We will discuss some more advanced features of activity diagrams in

Chapter 12, Working with XML.

8.7 Summary

The class-based exception handling concept greatly simplifies the process of deal-

ing with errors that can occur within an application. The definition of

common

framework for dealing with exceptions is essential for the development of reus-

able components because it provides a consistent model for propagating excep-

tions to users. In particular, the

RAISING

addition described in Section 8.4.3,

Propagating Exceptions, helps complete the signature of methods by fully speci-

fying a method's API contract.

In the next chapter, we will look at ways to simplify the testing of these methods

to ensure that their implementation satisfies the conditions outlined in their API

contract.

231

Unit tests measure the correctness of individual software modules,

helping developers identify bugs earlier in the software development

lifecycle. Unit testing frameworks such as ABAP Unit assist developers in

writing quality unit tests. In this chapter, you will learn how to develop

and execute unit tests using the ABAP Unit testing framework.

9 Unit Testing with ABAP Unit

During the implementation phase of

SAP project, ABAP developers find them-

selves in a fairly consistent routine of coding, compiling, activating, running, and

testing their individual development objects. At this stage, the testing process is

fairly informal, providing developers with a quick checkpoint to make sure that

they are progressing on the right track. Of course, if errors are found, the code is

changed on the spot and tested again. After the code reaches a stable state, it is

ready for a more formalized unit test.

Unit tests verify the correctness of an individual software unit. In terms of ABAP

development, this generally refers to a single method in a class, a subroutine, a

function module, and so on. If you have ever worked with unit tests before, this

view of unit tests might seem a bit unorthodox because the individual unit tests

are so narrow in scope. This point of confusion likely stems from the IEEE defini-

tion, which broadly describes unit testing as "testing of individual hardware or

software units or groups of related units."

As you will see, ABAP Unit supports

both views of unit testing by allowing you to flexibly group individual unit tests

together during test runs.

One of the main goals of eveiy unit test is to confirm that your individual mod-

ules are fulfilling the terms of their API contracts. Verifying this behavior early on

helps to eliminate the tedious module-level bugs that prohibit integration and

1 This explanation of unit testing scope was detailed in the book JUnit in Action (Manning, 2004).

The actual definition was taken from the IEEE Standard Computer Dictionary: A Compilation of IEEE

Standard Computer Glossaries (IEEE, 1990).

233

9 | Unit Testing with A8AP Unit

functional tests from running smoothly. In this chapter, you will learn how the

ABAP Unit test tool can support you in the process of developing and executing

unit tests.

9.1 ABAP Unit Overview

ABAP Unit is a testing framework that allows you to build automated tests of indi-

vidual units of software (e.g., function modules, class methods, etc.). In this sec-

tion, we will introduce the basic concepts of ABAP Unit in particular and unit test-

ing frameworks in general.

9.1.1 The Need for Unit Testing Frameworks

Frequently, unit tests are conducted by feel. For example, module pool applica-

tions are often tested by clicking buttons on the screen and seeing what happens.

If the screen doesn't blow up, and a record is written to the database (which you

can verify in Transaction SE16), then perhaps eveiything is working correctly.

However, more careful inspection might show that certain screen progressions or

inputs cause the database record to be written incorrectly, and so on.

In this case, developers often take the test to the next level by enlisting the aid of

the ABAP Debugger. Here, they can step through the code line-by-line to verify

that inputs are processed correctly, and so on. Occasionally, certain modules are

so difficult to test by hand that they require a special testing program to be writ-

ten. These makeshift programs usually contain logic to automate certain test tasks

that are too difficult to perform manually.

Having considered some of the various options for conducting unit tests, let's

take a step back and consider some of the problems associated with these kinds of

informal testing methods:

• "Feel tests" are basically just functional tests in disguise. Clearly, unit tests and

functional tests have a similar objective: to produce a working product or mod-

ule.

However, the approach is very different for each type of test. Functional tests

are "black box" tests designed by functional analysts that typically have little to

234