A Practical Guide to Testing Object-Oriented Software [Paperback]

John D. McGregor (Author), David A. Sykes (Author)

Book Description

Publication Date: March 15, 2001 | ISBN-10: 0201325640 | ISBN-13: 978-0201325645 | Edition: 1

While developers and IT organizations increasingly acknowledge the importance of software testing, few know how to proceed -- especially when it comes to testing advanced object-oriented software systems. In this book, two leading O-O test researchers and consultants outline a start-to-finish methodology for testing: what to test, why to test it, how to test it, who should do the testing, and when. The book is organized around a task orientation, encompassing testing models; testing components, systems and subsystems; and planning for testing. The authors review the unique challenges associated with object-oriented software testing, offer practical insights into testing priorities, introduce each leading testing technique, and walk step-by-step through applying them. They review the development of custom test software, and demonstrate how to strengthen the ties between testing and the rest of the development process. Features include a detailed object-oriented testing FAQ, and a running case study that ties together all stages and elements of O-O testing. For every IT manager, project manager, software developer and engineer, and for any professional concerned with the measurement of software quality.

Editorial Reviews

From the Inside Flap

Testing software is a very important and challenging activity. This is a book for people who test software during its development. Our focus is on object-oriented and component-based software, but you can apply many of the techniques discussed in this book regardless of the development paradigm. We assume our reader is familiar with testing procedural software--that is, software written in the procedural paradigm using languages such as C, Ada, Fortran, or COBOL. We also assume our reader is familiar and somewhat experienced in developing software using object-oriented and component-based technologies. Our focus is on describing what to test in object-oriented development efforts as well as on describing techniques for how to test object-oriented software, and how testing software built with these newer technologies differs from testing procedural software.

What is software testing? To us, testing is the evaluation of the work products created during a software development effort. This is more general than just checking part or all of a software system to see if it meets its specifications. Testing software is a difficult process, in general, and sufficient resources are seldom available for testing. From our standpoint, testing is done throughout a development effort and is not just an activity tacked on at the end of a development phase to see how well the developers did. We see testing as part of the process that puts quality into a software system. As a result, we address the testing of all development products (models) even before any code is written.

We do not necessarily believe that you will apply everything we describe in this book. There are seldom enough resources available to a development effort to do all the levels and kinds of testing we would like. We hope you will find a number of approaches and techniques that will prove useful to and affordable for your project.

In this book we describe a set of testing techniques. All of the techniques we describe have been applied in practice. Many of these techniques have been used in a wide variety of industries and on projects of vastly different sizes. In Chapter 3, we will consider the impact of some of these variables on the types of testing that are routinely performed.

To describe these techniques, we rely in many cases on one or more examples to illustrate their application. We hope from these examples and from our explanations that you can apply the same techniques to your project software in a straightforward manner. The complete code for these examples, test code, and other resources can be obtained via a link off this Web site.

In order to make this book as useful as possible, we will provide two major organizational threads. The physical layout of the book will follow the usual sequence of events as they happen on a project. Model testing will be addressed earlier than component or code testing, for example. We will also include a set of questions that a tester might ask when he or she is faced with specific testing tasks on a project. This testing FAQ will be tied into the main body of the text with citations.

We have included alternative techniques and ways of adapting techniques for varying the amount of testing. Testing life-critical or mission-critical software requires more effort than testing an arcade game. The summary sections of each chapter should make these choices clear.

This book is the result of many years of research, teaching, and consulting both in the university and in companies. We would like to thank the sponsors of our research, including COMSOFT, IBM, and AT&T for their support of our academic research. Thanks to the students who assisted in the research and those who sat through many hours of class and provided valuable feedback on early versions of the text. The consultants working for Korson-McGregor, formerly Software Architects, made many suggestions and worked with early versions of the techniques while still satisfying client needs. The employees of numerous consulting clients helped us perfect the techniques by providing real problems to be solved and valuable feedback. A special thanks to Melissa L. Russ (formerly Major) who helped teach several tutorials and made her usual insightful comments to improve the material.

Most of all, we wish to thank our families for enduring our mental and physical absences and for the necessary time to produce this work: Gayle and Mary Frances McGregor; Susan, Aaron, Perry, and Nolan Sykes.JDM
DAS 0201325640P04062001

From the Back Cover

A Practical Guide to Testing Object-Oriented Software focuses on the real-world issues that arise in planning and implementing effective testing for object-oriented and component-based software development. It shows how testing object-oriented software differs from testing procedural software and highlights the unique challenges and opportunities inherent in object-oriented software testing.

The authors reveal how object-oriented software development allows testing to be integrated into each stage of the process--from defining requirements to system integration--resulting in a smoother development process and a higher end quality. As they follow this process, they describe what to test at each stage as well as offer experienced-based testing techniques.

You will find information on such important topics as:

• Testing analysis and design models, including selecting test cases to guide design inspections
• Testing components, frameworks, and product lines
• The testing challenges of inheritance and polymorphism
• How to devise an effective testing strategy
• Testing classes, including constructing a test driver and test suites
• Testing object interactions, covering sampling test cases, off-the-shelf components, protocol testing, and test patterns
• Testing class hierarchies, featuring subclass test requirements
• Testing distributed objects, including threads, life cycle testing, and Web server testing
• Testing systems, with information on stress, life cycle, and performance testing

One comprehensive example runs throughout the book to demonstrate testing techniques for each stage of development. In addition, the book highlights important questions that testers should ask when faced with specific testing tasks.

The authors acknowledge that testing is often viewed as a necessary evil, and that resources allocated to testing are often limited. With that in mind, they present a valuable repertoire of testing techniques from which you can choose those that fit your budget, schedule, and needs.

0201325640B04062001

See all Editorial Reviews

Product Details

• Paperback: 416 pages
• Publisher: Addison-Wesley Professional; 1 edition (March 15, 2001)
• Language: English
• ISBN-10: 0201325640
• ISBN-13: 978-0201325645
• Product Dimensions: 9.3 x 7.3 x 0.9 inches
• Shipping Weight: 1.5 pounds (View shipping rates and policies)
• Average Customer Review: 3.4 out of 5 stars  See all reviews (5 customer reviews)
• Amazon Best Sellers Rank: #1,306,630 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

35 of 35 people found the following review helpful:

5.0 out of 5 stars Thorough, wide and deep coverage of O-O testing, April 19, 2001

By 

Mike Tarrani "www.tarrani.com" (Deltona, FL USA) - See all my reviews
(COMMUNITY FORUM 04)    (REAL NAME)   

This review is from: A Practical Guide to Testing Object-Oriented Software (Paperback)

I purchased this book to use as a guide for developing a strategy to validate directory-enabled security infrastructures. It met my requirements and more. I discovered that this is also a great introduction to object-orientation for test professionals new to the paradigm. Also, because this book covers every facet of O-O testing it is also useful to testers who have worked in the O-O environment.

It starts out with a good description of the differences and unique challenges of testing O-O software. It then covers the basics. Starting with test planning it provides a clear approach to performing this important task in the O-O environment. This material can also be used as best practices for testing in any environment. I especially liked the chapter on testing analysis and design models. In particular, this chapter validated my personal theories on the way to approach design validation of directory services, such as LDAP, that are becoming a prevalent component of enterprise security infrastructures. The next three chapters address testing classes, interactions and class hierarchies. These chapters cover the foundation of O-O testing and provide those who are new to O-O testing with a clear view of what's important and how to approach developing a test strategy and cases, and performing the actual testing.

The book moves into advanced topics in the chapter on testing distributed objects. This is a complex subject and developing a test strategy in this area is a daunting task. The authors cover this material in depth, and provide a clear and complete description of all issues and factors. I was impressed with thoroughness and attention paid to the most minute detail. The authors include life cycle testing, which makes this book also important to software quality assurance (SQA) professionals. Note, SQA and testers are two different groups with two different sets of objectives. Where the tester is concerned with trying to break software, SQA collects metrics and devises process improvement with respect to defect prevention. The authors' approach contains something for each of these groups. The next level of testing granularity that is addressed is testing whole systems. This chapter covers the entire range, including stress testing, the wider considerations of system life cycle testing, embedded software, multi-tiered systems and more. Because my interest was testing security infrastructures I was pleased to see that the authors included security testing in this chapter. This is an added bonus, and shows the thoroughness with which the book approaches testing in the whole.

Other topics that make this a valuable book for test professionals are included in the chapter on components, frameworks and product lines. The authors show the differences between testing objects and components, and cover topics such as enterprise java beans, inspecting and testing frameworks, and interface testing.

Overall this is a comprehensive book that covers every conceivable task and topic related to O-O testing. It is well written and contains many pleasant surprises, such as security testing, and well developed test strategies for any environment with which an O-O tester will be confronted. It provided me with the exact answers to some thorny questions about validating and testing directory-enabled security, and taught me a lot more about O-O testing along the way.

5 of 6 people found the following review helpful:

2.0 out of 5 stars the usual not practical book, November 18, 2004

By 

Stephan Wiesner (Switzerland) - See all my reviews
(REAL NAME)   

This review is from: A Practical Guide to Testing Object-Oriented Software (Paperback)

The book describes object orientation. Oh, come on, folks, there are tons of books on that topic and they do it better.
The contents are very object orientation centered. In my experience as a tester, I don't care about the use language, paradigm or what ever (except for reviews of course). To me it seems that OO was new to the authors and they thought it would demand many new testing strategies, which it doesn't (after the JUnit testing of course).
The proposed procedures look very much like something used at a university, but are not practical in the real world.
I am a tester and test manager and I certainly did not found any help in here.

5 of 7 people found the following review helpful:

1.0 out of 5 stars Not very practical at all, January 10, 2006

By 

Andrew - See all my reviews

This review is from: A Practical Guide to Testing Object-Oriented Software (Paperback)

As you might expect from a couple of academic professors this book is full of formal processes that are easy to teach and write exams around but don't scale to the real world.

The book spends 47 pages covering the basics of object oriented design (class, object, inheritance etc) and UML diagrams (class diagrams, state diagrams, sequence diagrams) yet completely ignores basic testing concepts such as white and black box testing. The book also has zero coverage of popular testing tools such as JUnit and NUnit that are making a real difference in test productivity and code quality these days.

I found only two useful ideas in the book, guided inspection and orthogonal array testing. Guided inspection is documented in mind numbing detail but unfortunately the book does such a poor job of explaining orthogonal array testing that I had to go and research it on the web.

Surprisingly for a book that claims to be a practical guide the exercises are largely ambiguous and open-ended essay style questions. The authors provide snippets of a breakout-style game that they use as a running example throughout the book. The exercises could have been so much better if they had included a design and implementation of a simpler application and set practical problems based on that code. If, like me, you learn through doing then you won't get much help from this book.

I doubt I will pick this book up again anytime soon and neither will I be recommending it to any of my friends or coworkers.