Software Testing Books: Load Testing, Unit Testing, Functional Testing

Growing Object-Oriented Software, Guided by Tests

Software Testing Magazine — Wed, 05 Jan 2022 15:49:38 +0000

Object orientation (OO) is not a trendy concept anymore, but it hasn’t certainly lost it values. The purpose of the book “Growing Object-Oriented Software, Guided by Tests” is to integrate the development of object-oriented software with the Agile testing Test-Driven Development (TDD) approach, more specifically in Java. It starts with an introduction to TDD and the open source testing tools (Junit, jMock2) that will be used in the examples. Then, it describes in detail the TDD process that is then illustrated by a large example. The book ends with more software testing topics like tests smells or tests readability. A final part is dedicated to special aspects of testing Java code like persistence, threads and asynchronous code. The book “Growing Object-Oriented Software, Guided by Tests” written by Steve Freeman and Nat Pryce could be read from start to end or be used as a reference book. In the preface, the authors say that the book is intended for developers with professional experience and some first knowledge of TDD. It really goes far beyond “toy” examples that you can find in programming learning books to write your first “Hello Word” program. The content is a balanced mix of concepts, examples and diagrams that makes it easy to read. Besides what could be considered “catchy” acronyms (OO+TDD), this book is an excellent reference on how to design and program software (the authors use the nice concept of “growing” software). I will consider this book as a must-read for anyone programming in Java, [...]

The post Growing Object-Oriented Software, Guided by Tests first appeared on Software Testing Magazine.

Continuous Integration: Improving Software Quality and Reducing Risk

Software Testing Magazine — Mon, 09 Aug 2021 14:39:00 +0000

As a software developer, you know that one of the critical period in a project is when you try to make integrate your code in the overall application and push it towards the final user. It is sometimes a long process that you would like to accelerate so that you could obtain a quicker feedback on the quality of your code. “Continuous Integration: Improving Software Quality and Reducing Risk” is a book written by Paul Duvall, with Steve Matyas and Andrew Glover that will help you improve the way you build and deliver software. After an initial presentation of the continuous integration (CI) concepts and objectives, the content of the book goes far beyond the simple “continuous build” aspect to cover all disciplines concerned by CI: risk management, configuration management, database evolution, software testing, inspections, deployment. It is clear that CI is just not installing a suite of tools, but is mainly changing software development practices and process. Each chapter is well-structured with practical examples related to real life situations. The book reach also nicely the objective of maintaining a balance between a somewhat tools- and language-neutral position, but still giving enough practical advice so that you could quickly adapt the advice to your own software development environment. Final appendixes give valuable information on CI resources and evaluating available CI tools. Finally, you can get more and updated information on continuous integration from the website associated to the book: http://www.integratebutton.com Reference: Continuous Integration: Improving Software Quality and Reducing Risk; Andrew [...]

The post Continuous Integration: Improving Software Quality and Reducing Risk first appeared on Software Testing Magazine.

The Software Testing Fuzzing Book

Software Testing Magazine — Tue, 05 Jan 2021 16:18:12 +0000

The Fuzzing Book is a website / online book that presents tools and techniques for generating software tests. Fuzzing is defined by Wikipedia as “automated software testing technique that involves providing invalid, unexpected, or random data as inputs to a computer program. The program is then monitored for exceptions such as crashes, failing built-in code assertions, or potential memory leaks.” This online book addresses this problem by automating software testing, specifically by generating tests automatically. Recent years have seen the development of novel techniques that lead to dramatic improvements in test generation and software testing. They now are mature enough to be assembled in a book – even with executable code. With 17,000 lines of Python code and 125,000 words of text, a printed version would cover more than 1,000 pages of text. This work is designed as a textbook for a course in software testing; as supplementary material in a software testing or software engineering course; and as a resource for software developers. It covers random fuzzing, mutation-based fuzzing, grammar-based test generation, symbolic testing, and much more, illustrating all techniques with code examples that you can try out yourself. While the chapters of this book can be read one after the other, there are many possible paths through the book and it is not assumed that everybody wants to read everything. The multiple authors have provided a graph to navigate through the content. There are also some preset “tours” that will guide you whether you are an experienced pragmatic [...]

The post The Software Testing Fuzzing Book first appeared on Software Testing Magazine.

Implementing Automated Software Testing

Software Testing Magazine — Mon, 23 Nov 2020 12:00:32 +0000

This book “Implementing Automated Software Testing”, Elfriede Dustin, Thom Garrett and Bernie Gauf presents a comprehensive treatment of the domain of software testing automation. The first part defines and describes test automation, proposing a business case for automation and discussing the pitfalls that should be avoided. The second part is a roadmap for test automation. It gives six keys for software testing automation payoff: 1. Know your requirements 2. Develop a strategy 3. Test your tools 4. Track progress and adjust 5. Implement the process 6. Put the right people in the process. Four appendixes complete the book. They provide a process checklist, explain how automation applies to various testing types, discuss tools evaluation and give a case study. The fact that the authors have worked with the Defense industry might have affected the way the book was conceived and written: with structure and rigor. The discussions, references and tools suggestions apply however to every software testing situation and not only to organization that are strongly process oriented. The aim of the book is to be a guide that can help to implement successfully automated software testing and it certainly achieves its objective. Reference: “Implementing Automated Software Testing”, Elfriede Dustin, Thom Garrett & Bernie Gauf, Addison Wesley. Quotes Although much attention is generally paid to the cost of software development, and much excitement is generated from technologies that offer development productivity improvement, the cost and productivity of software testing are often ignored or just accepted as “this is what it [...]

The post Implementing Automated Software Testing first appeared on Software Testing Magazine.

Experiences of Test Automation

Software Testing Magazine — Mon, 22 Jun 2020 14:59:56 +0000

“Tools and machines are great, but in the end, it is the people who matter. Putting together an effective automated test team requires lots of planning and skills.” This might the emblematic quote of this great book about software testing automation. The book groups case studies written each by a different author. Each case study is presented in the preface, so you can pick the story that you prefer, based on many criteria like application domain, tool type… or if the project was successful or not. I think that this is the unique selling proposition of this book: each chapter is the story of a personal journey through a test automation effort, with its good and bad days. One of my favorite chapters describes the effort to automate the tests at a vendor of software testing tools. On top of this, the two editors have done a very good job to present all stories, highlighting the lessons they tell us and putting them in perspective of the testing automation domain. This book is highly recommended to every software tester and to all developers that want to produce higher quality code or are wise enough not to consider every software tester as a frustrated wannabe programmer unable to recognize the beauty and efficiency of their beautifully crafted code. Reference: “Experiences of Test Automation – Case Studies of Software Test Automation”, Dorothy Graham and Mark Fewster editors Addison-Wesley, 605 pages Quotes Automation code, including scripts, is software and, like all software, can [...]

The post Experiences of Test Automation first appeared on Software Testing Magazine.

Quality Code: Software Testing Principles, Practices, and Patterns

Software Testing Magazine — Tue, 04 Feb 2020 16:34:10 +0000

There are many books about software testing, but Quality Code is among the best that I have read. It presents a philosophy about software testing that has been mine in my previous life as a software developer: the programmer is the main person responsible for the quality of its code. Stephen Vance describes the goal of his book as “This book is about easily and routinely testing all of your software. It primarily focuses on unit tests, but many of the techniques apply to higher-level tests as well. This book will give you the tools – the implementation patterns – to test almost any code and to recognize when the code needs to change to be testable.” The book is aimed at professional software developers and it provides a lot of practical examples in code that is readable even if you don’t program with this specific language. This practical part is preceded by an introduction that describes the principles and theory of software testing, discussing for instance the different nuances of the black and white approaches or explaining how some programming patterns make the code difficult to test. My favorite part is indeed this chapter devoted to design and testability. Everything is presented in a way that is easy to read, even the parts with meaningful code examples. Quality Code is a book that I will strongly recommend to every software developer that is convinced that code quality is his main responsibility and not something that will be eventually managed [...]

The post Quality Code: Software Testing Principles, Practices, and Patterns first appeared on Software Testing Magazine.

Lean-Agile Acceptance Test-Driven Development

Software Testing Magazine — Wed, 10 Jul 2019 07:52:21 +0000

Acceptance tests are defined in this book as the test created by the customer in collaboration with the developer and the tester prior to implementation. They are not the traditional user acceptance tests performed after implementation. Although acceptance tests can be used at different development stages, Ken Pugh proposes mainly in this book an approach where all project stakeholders will collaborate to create tests that validate business requirements. The book is clearly written and easy to read. At the end of each chapter, a summary proposes the main points discussed. The author proposes a lot of practical examples and case studies that help to apply the concepts discussed to real cases. Some chapters are only focused on the “how to” aspect of Acceptance Test-Driven Development (ATDD) and an appendix shows how to implement it with different tools like Fit or Cucumber. As the book insists about the collaboration between the users, developers and testers, I can recommend it not only to software testers in Agile teams, but to all project team members that want to improve their communication with end users and achieve a better understanding of requirements. Reference: “Lean-Agile Acceptance Test-Driven Development”, Ken Pugh, Addison-Wesley, 332 pages, IBSN 978-0-321-71408-4 Quotes Developing software with testable requirements is the theme of this book. A testable requirement is one with an acceptance test. Acceptance tests drive the development of the software. As many development groups have experienced, creating acceptance tests prior to implementing requirements decreases defects and improves productivity. (See the Epilogue [...]

The post Lean-Agile Acceptance Test-Driven Development first appeared on Software Testing Magazine.

More Agile Testing

Software Testing Magazine — Tue, 14 May 2019 15:08:44 +0000

The “More Agile Testing” book is the sequel to the book Agile Testing written by Janet Gregory and Lisa Crispin. This book continues to explore the topic of software testing in an Agile context. It provides more than 500 pages of Agile knowledge to the software testing community, building on the Agile Testing foundations described in their first book. The book covers many topics like the software testing skills, planning testing in an Agile context or testing the delivery of business values at the end of Scrum sprints. My favorite part of the book is the “testing in context” part that explores the particularities of testing embedded software, mobile apps or data warehouses. One of the very good ideas of the book is to ask Agile software testing experts to contribute to the book. Readers are able to learn the perspective of people like Gojko Adzic or Ellen Gottesdiener on specific topics. Another little gem of the book is the “Provocation Starters” appendix that lists questions about your product and that you can use to elicit examples or uncover assumptions. More Agile Testing has a good structure, each chapter having a clear description of what will be discussed and a summary at the end. It is well-written and easy to read, mixing explanations of concepts with examples that allow putting them in perspective. I recommend this book to every software tester, even if they are not active in an Agile project, but also to every Agile developer, Scrum Masters and [...]

The post More Agile Testing first appeared on Software Testing Magazine.