Most Helpful Customer Reviews
16 of 16 people found the following review helpful:
5.0 out of 5 stars
A significant contribution to the software QA profession, March 18, 2004
This review is from: Effective Software Test Automation: Developing an Automated Software Testing Tool (Paperback)
Before proceeding you need to know that this book is specific to the Microsoft .NET environment, and is not a general book on test automation. That said, this is possibly one of the most important books recently published on the subject for those who develop for Microsoft technologies. Moreover, the tool it leads you through developing is worth many times the price of the book. The best way to describe this book's strengths and benefits is to align them to three different classes of reader who will benefit the most: (1) developers or QA practitioners who need to quickly implement a testing tool that dramatically reduces the time it takes to execute test cycles. This book will service this audience as a technical manual for the tool, which can be downloaded in source and binary formats from the publisher's web site. (2) developers who want a baseline tool that can be extended and modified to suit their specific needs, or to be integrated into (or augment) a suite of existing testing tools. The clear explanation of how this tool was designed and the code that makes up the tool will easily meet this audience segment's needs. More importantly, the book even shows how to develop assemblies with which to test the tool. (3) developers who want to improve their own skills by examining an integrated application that has been engineered by experts. The tool upon which this book is based is one of the most elegantly designed and implemented examples of good programming practices and software engineering. Not only does it show how to harness some of the capabilities of the .NET framework and associated IDE, but also shows how to integrate into Microsoft Office applications and create a seamless enterprise application. The tool in this book is integrated into Microsoft Excel (version 2000), and the concepts, use of XML, and the way everything is tied into a coherent application that provides useful services exemplify how to develop business applications. The tool itself is one of the most useful and clever test automation approaches I've seen in any environment. It auto-discovers what must be tested, and develops test scripts with virtually no intervention on the part of QA. It also dramatically reduces test time, and will significantly contribute to the deployment of defect-free applications, especially in a rapid development environment (such as those shops using extreme programming or agile methods). While the tool will not completely replace other testing tools, it will nicely augment them. I think the best use of this tool is in the development domain to be used for unit and integration testing. It also supports incremental regression testing, which can be effectively executed by the build manager before promoting to QA for final test and release. Of course, this tool will also fit nicely within the QA domain, especially with its ability to support both white- and black-box testing. In combination this book and the associated tool are, in my opinion, important contributions to the QA profession, and to teams working with Microsoft technologies.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
14 of 14 people found the following review helpful:
2.0 out of 5 stars
Reinventing the wheel? Limited and fails to Deliver, December 11, 2005
This review is from: Effective Software Test Automation: Developing an Automated Software Testing Tool (Paperback)
Kanglin Li's "Effective Software Test Automation" which is subtitled as "Developing an Automated Software Testing Tool" fails to deliver what it promises to be, a solution to automated software testing. The core emphasis of this book is on reflection based correctness evaluation and showing a .NET implementation for this. It gives a brief introduction to commercial testing toolkits available for instance Compuware's DevPartner Studio, Parasoft's Insure++, Mercury's Interactive, Object Tester, IBM's Rational Suite, Segue S/w, Testworks as well as open source tools like Ant (not a testing tool by the way), Junit, Jprobe Cactus and HttpUnit. In the meantime, it conviniently leaves out Nunit which essentially does the same thing explained in this book and in a much better and more efficient way. Test scripts are easier to write, automate and it's open source with a VS.NET IDE plug-in. An optimist's note; it discusses usage of Excel automation and XML manip from from C# which provides some good code recipes with explanations. Also the early phase test scripts for test driven development / XP practices is a good overview. It's just that this is not the core purpose of the book. I found this book serving little purpose for developers test automation solution provision since there are several existing open source / commercial tools available in market which provide a better feature-set. However, if you are interested in learning reflection, want to extend an existing in-house testing framework for .NET, want to learn how test cases be created against assemblies etc, it might worth a read.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
12 of 13 people found the following review helpful:
4.0 out of 5 stars
Useful, Focused and a Good .Net Hands-On Case Study, March 14, 2004
This review is from: Effective Software Test Automation: Developing an Automated Software Testing Tool (Paperback)
Effective Software Test Automation presents a hands-on case study with code to create a test tool capable of generating test scripts, data stores and output summary. While the concepts discussed certainly apply to the development of most tools, the code provided is specific to the .Net environment using C# as the development language, and the bulk of the book is dedicated to describing how the tool is created in that environment with full code listings. I would recommend this book to testers and developers who are new to the .Net development environment or those who may have worked in it and want to start considering a tool to generate test scripts. This book accomplishes two important goals. The first is the step by step creation of the test tool. I implemented the code to create the automated test tool to generate the data store and the test script up through chapter 7 without any problems. It worked as described, and the code, along with its description, for the remainder of the book was well presented. The second significant contribution the book makes is the tour it takes the reader through aspects of the .Net environment. It demonstrates the robust development qualities in .Net. An example of this is the hands-on discussion of the namespace system.Reflection. Further, it provides an insightful guide to referencing the MS Excel Object Library through example as the code dynamically creates a datastore in an Excel worksheet. The authors also provide an overview on how to use the tool effectively and provide adequate notes on usage context. Towards the latter part of the book they are adamant that testers still need to analyze the requirements and understand the data used to test the application. For instance, testers still need to understand concepts such as boundary value analysis, equivalence partitions and other testing techniques which are more thoroughly addressed in other theoretical texts. It should be noted, that the tool presented by the authors does not guarantee code coverage (i.e. path analysis within a method). Readers will have a better appreciation for the tool if they study some of the classics in testing theory by Glenford Myers, Robert Poston and Paul C. Jorgensen. The tool itself is certainly useful from the standpoint of regression testing. In other words, once an application is stable in its functionality, the test scripts generated can form a baseline of testing when changes are introduced. The authors do mention XP, but I have to comment as to the effective use of the tool in XP development. In XP, testing is based on test driven development (TDD). In TDD, the test script is written BEFORE the implementation code is ever produced. In TDD (agile development) the test harness is an up front statement of the design stating what the code should do - not what it already does because it hasn't been written yet. Their tool requires the implementation code (actually, the assembly) to be created before it creates the test script. Again, though, there are many development efforts where TDD is not used (the majority actually ) and the tool the authors present provides a good start for analysis of code completed by developers to generate an initial set of scripts when a maintenance environment receives transitioned code. Their observations of the spirit of XP are very accurate. I am only expressing a philosophical concern in the testing arena. In essence, the tool can have benefits, but like any tool should be used in the proper context. Developers should not assume that any tool can replace human intuition and solid testing techniques. Overall, I found the book to be well focused and clearly written. I only have two criticisms of the book itself, which is why I would rate it four out of five stars (which for me is a good rating). I think the title or cover should have noted something about .Net (e.g. "A Case Study Using .Net"), even though the authors claim the concepts are generic. The concepts are, but the implementation is not since legacy programming environments do not have support for integrating an XML framework in the code for comments. In my previous life as a UNIX and C developer and considering the cost, I would get very little benefit from the text since the "generic" part is limited after Chapter 2. Second, while the authors provided a high level discussion of the features the tool would provide in the later part of Chapter 2, it would have been helpful had there been illustrations with a brief description of how it would be used earlier. The tool creation was presented piece by piece, and while I was able to follow along with the authors, I found myself immediately skipping ahead to Chapter 7 to get an idea of what the end product would look like. After doing so, I went back to where I left off in Chapter 4 and the rest was fine. It's a small thing actually, but an early picture or two of where the code is taking the reader is helpful.
Help other customers find the most helpful reviews
Was this review helpful to you? Yes
No
|
