<srw:searchRetrieveResponse xmlns:srw="http://www.loc.gov/zing/srw/">
    <srw:version>1.2</srw:version>
    <srw:numberOfRecords>10</srw:numberOfRecords>
    <srw:echoedSearchRetrieveRequest>
        <srw:version>1.2</srw:version>
        <srw:query></srw:query>
        <srw:xquery/>
        <srw:startRecord>1</srw:startRecord>
        <srw:maximumRecords>10</srw:maximumRecords>
        <srw:recordSchema>mods</srw:recordSchema>
    </srw:echoedSearchRetrieveRequest>
    <srw:records>
    <srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>1</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Essentials of software testing /</title></titleInfo><name type="personal" usage="primary"><displayForm>Bierig, Ralf,</displayForm><namePart type="date">1976-</namePart><role><roleTerm type="text">author.</roleTerm></role></name><name type="personal"><displayForm>Brown, Stephen C. (Stephen Charles),</displayForm><namePart type="date">1961-</namePart><role><roleTerm type="text">author.</roleTerm></role></name><name type="personal"><displayForm>Galván, Edgar,</displayForm><namePart type="date">1977-</namePart><role><roleTerm type="text">author.</roleTerm></role></name><name type="personal"><displayForm>Timoney, Joseph,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">enk</placeTerm></place><place><placeTerm type="text">Cambridge :</placeTerm></place><publisher>Cambridge University Press,</publisher><dateIssued>2022.</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2022</dateIssued><edition>First edition.</edition><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (xiii, 304 pages) : digital, PDF file(s).</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Software testing can be regarded as an art, a craft, and a science. The practical, step-by-step approach presented in this book provides a bridge between these different viewpoints. A single worked example runs throughout, with consistent use of test automation. Each testing technique is introduced in the context of this example, helping students see its strengths and weaknesses. The technique is then explained in more detail, providing a deeper understanding of underlying principles. Finally the limitations of each technique are demonstrated by inserting faults, giving learners concrete examples of when each technique succeeds or fails in finding faults. Coverage includes black-box testing, white-box testing, random testing, unit testing, object-oriented testing, and application testing. The authors also emphasise the process of applying the techniques, covering the steps of analysis, test design, test implementation, and interpretation of results. The book's web site has programming exercises and Java source code for all examples.</abstract><tableOfContents>Cover -- Half-title -- Title page -- Copyright information -- Contents -- Preface -- Epigraph -- Acknowledgements -- 1 Introduction to Software Testing -- 1.1 The Software Industry -- 1.1.1 Software Testing and Quality -- 1.1.2 Software Testing and Risk Management -- 1.2 Mistakes, Faults, and Failures -- 1.2.1 Mistakes -- 1.2.2 Software Faults -- 1.2.3 Software Failures -- 1.2.4 Need for Testing -- 1.3 The Role of Specifications -- 1.4 Manual Test Example -- 1.5 The Theory of Software Testing -- 1.6 Exhaustive Testing -- 1.6.1 Exhaustive Test Data -- 1.6.2 Feasibility of Exhaustive Testing -- 1.7 Test Heuristics -- 1.7.1 Random Testing -- 1.7.2 Black-Box and White-Box Testing -- 1.7.3 Experience-Based Testing -- 1.7.4 Fault Insertion -- 1.8 When to Finish Testing -- 1.9 Static and Dynamic Testing -- 1.9.1 Review-Based Techniques -- 1.9.2 Program Proving -- 1.10 Testing in the Software Development Process -- 1.11 Software Testing Activities -- 1.11.1 Analysis -- 1.11.2 Test Coverage Items -- 1.11.3 Test Cases -- 1.11.4 Test Design Verification -- 1.11.5 Test Implementation -- 1.12 Test Artefacts -- 1.13 Fault Models -- 1.14 Using this Book -- 1.14.1 Book Structure -- 1.14.2 Order of Testing -- 1.14.3 Documenting Test Design -- 1.14.4 The Programming Language -- 1.14.5 Level of Detail -- 1.14.6 Examples -- 1.14.7 Software Test Tools -- 1.15 Notes on Terminology -- 2 Equivalence Partitions -- 2.1 Testing with Equivalence Partitions -- 2.2 Example -- 2.2.1 Analysis: Identifying the Equivalence Partitions -- 2.2.2 Test Coverage Items -- 2.2.3 Test Cases -- 2.2.4 Verification of the Test Cases -- 2.3 Test Implementation and Results -- 2.3.1 Manual Test Output -- 2.3.2 Automated Test Implementation -- 2.3.3 Test Results -- 2.4 Equivalence Partitions in More Detail -- 2.4.1 Fault Model -- 2.4.2 Description.</tableOfContents><tableOfContents>2.4.3 Analysis: Identifying Equivalence Partitions -- 2.4.4 Test Coverage Items -- 2.4.5 Test Cases -- 2.4.6 Pitfalls -- 2.5 Evaluation -- 2.5.1 Limitations -- 2.5.2 Strengths and Weaknesses -- 2.6 Key Points -- 2.7 Notes for Experienced Testers -- 3 Boundary Value Analysis -- 3.1 Testing with Boundary Value Analysis -- 3.2 Example -- 3.2.1 Analysis: Identifying the Boundary Values -- 3.2.2 Test Coverage Items -- 3.2.3 Test Cases -- 3.2.4 Verification of the Test Cases -- 3.3 Test Implementation and Results -- 3.3.1 Implementation -- 3.3.2 Test Results -- 3.4 Boundary Value Analysis in More Detail -- 3.4.1 Fault Model -- 3.4.2 Description -- 3.4.3 Analysis: Identifying Boundary Values -- 3.4.4 Test Coverage Items -- 3.4.5 Test Cases -- 3.4.6 Pitfalls -- 3.5 Evaluation -- 3.5.1 Limitations -- 3.5.2 Strengths and Weaknesses -- 3.6 Key Points -- 3.7 Notes for Experienced Testers -- 4 Decision Table Testing -- 4.1 Testing Combinations with Decision Tables -- 4.2 Example -- 4.2.1 Analysis -- 4.2.2 Test Coverage Items -- 4.2.3 Test Cases -- 4.2.4 Verification of the Test Cases -- 4.3 Test Implementation and Results -- 4.3.1 Implementation -- 4.3.2 Test Results -- 4.4 A More Detailed Look at Testing with Decision Tables -- 4.4.1 Fault Model -- 4.4.2 Description -- 4.4.3 Analysis: Developing Decision Tables -- 4.4.4 Test Coverage Items -- 4.4.5 Test Cases -- 4.4.6 Pitfalls -- 4.5 Evaluation -- 4.5.1 Limitations -- 4.5.2 Strengths and Weaknesses -- 4.6 Key Points -- 4.7 Notes for Experienced Testers -- 5 Statement Coverage -- 5.1 Introduction to White-Box Testing -- 5.2 Testing with Statement Coverage -- 5.2.1 Statement Coverage Measurement -- 5.3 Example -- 5.3.1 Analysis: Identifying Unexecuted Statements -- 5.3.2 Test Coverage Items -- 5.3.3 Test Cases -- 5.3.4 Verification of the Test Cases -- 5.4 Test Implementation and Results -- 5.4.1 Implementation.</tableOfContents><tableOfContents>5.4.2 Test Results -- 5.5 Statement Coverage Testing in More Detail -- 5.5.1 Fault Model -- 5.5.2 Description -- 5.5.3 Analysis: Identifying Unexecuted Statements -- 5.5.4 Test Coverage Items -- 5.5.5 Test Cases -- 5.6 Evaluation -- 5.6.1 Limitations -- 5.6.2 Strengths and Weaknesses -- 5.7 Key Points -- 5.8 Notes for Experienced Testers -- 6 Branch Coverage -- 6.1 Testing with Branch Coverage -- 6.1.1 Branch Coverage Measurement -- 6.2 Example -- 6.2.1 Analysis: Identifying Untaken Branches -- 6.2.2 Test Coverage Items -- 6.2.3 Test Cases -- 6.2.4 Verification of the Test Cases -- 6.3 Test Implementation and Results -- 6.3.1 Implementation -- 6.3.2 Test Results -- 6.4 Branch Coverage in More Detail -- 6.4.1 Fault Model -- 6.4.2 Description -- 6.4.3 Goal -- 6.4.4 Analysis: Identifying Untaken Branches -- 6.4.5 Test Coverage Item -- 6.4.6 Test Cases -- 6.5 Evaluation -- 6.5.1 Limitations -- 6.5.2 Strengths and Weaknesses -- 6.6 Key Points -- 6.7 Notes for Experienced Testers -- 7 All Paths Coverage -- 7.1 Testing with All Paths Coverage -- 7.2 Example -- 7.2.1 Code Analysis -- 7.2.2 Test Coverage Items -- 7.2.3 Test Cases -- 7.2.4 Verification of the Test Cases -- 7.3 Test Implementation and Results -- 7.3.1 Implementation -- 7.3.2 Test Results -- 7.4 All Paths Coverage Testing in More Detail -- 7.4.1 Fault Model -- 7.4.2 Description -- 7.4.3 Analysis: Developing Control-Flow Graphs -- 7.4.4 Analysis: Identifying End-to-End Paths -- 7.4.5 The Possible Paths in Fault 6 -- 7.4.6 Test Coverage Items -- 7.4.7 Test Cases -- 7.5 Evaluation -- 7.5.1 Limitations -- 7.5.2 Strengths and Weaknesses -- 7.6 Key Points -- 7.7 Notes for the Experienced Tester -- 8 Black-Box and White-Box Testing -- 8.1 Comparison of Black-Box and White-Box Testing -- 8.1.1 Black-Box Testing -- 8.1.2 White-Box Testing -- 8.1.3 Errors of Omission and Commission -- 8.1.4 Usage.</tableOfContents><tableOfContents>8.2 Black-Box Testing: Additional Matters -- 8.2.1 Strings and Arrays -- 8.2.2 Discontinuous Input Partitions -- 8.2.3 Overlapping Output Partitions -- 8.2.4 In-band Error Reporting -- 8.2.5 Handling Relative Values -- 8.2.6 Classic Triangle Problem -- 8.2.7 Testing Sequences of Inputs/State-Based Testing -- 8.2.8 Floating Point Numbers -- 8.2.9 Numeric Processing -- 8.3 White-Box Testing: Some More Techniques -- 8.3.1 Dataflow Coverage/Definition-Use Pairs -- 8.3.2 Condition Coverage -- 8.3.3 Decision Coverage -- 8.3.4 Decision Condition Coverage -- 8.3.5 Multiple Condition Coverage -- 8.3.6 Modified Condition/Decision Coverage -- 8.3.7 Test Ranking -- 8.4 Repair-Based Testing -- 8.4.1 Specific Repair Test -- 8.4.2 Generic Repair Test -- 8.4.3 Abstracted Repair Test -- 8.4.4 Example -- 8.4.5 Using Repair-Based Tests -- 9 Testing Object-Oriented Software -- 9.1 Testing in Class Context -- 9.2 Example -- 9.2.1 Analysis -- 9.2.2 Deciding on Which Methods to Test -- 9.2.3 Selecting a Test Technique -- 9.2.4 Test Coverage Items -- 9.2.5 Test Cases -- 9.2.6 Verification of the Test Cases -- 9.3 Test Implementation and Results -- 9.3.1 Test Implementation -- 9.3.2 Test Results -- 9.4 A More Detailed Look at Testing Object-Oriented Software -- 9.4.1 Object-Oriented Programming -- 9.4.2 Testing Object-Oriented Software -- 9.4.3 Fault Models -- 9.4.4 Testing in Class Context -- 9.4.5 Analysis for OO Testing -- 9.4.6 Test Coverage Items -- 9.4.7 Test Cases -- 9.4.8 Test Implementation -- 9.4.9 Overview of Advanced OO Testing -- 9.4.10 Inheritance Testing -- 9.4.11 State-Based Testing -- 9.4.12 UML-Based Testing -- 9.4.13 Built-In Testing -- 9.5 Evaluation -- 9.5.1 Limitations -- 9.5.2 Simple Typo Fault -- 9.5.3 State-Based Fault -- 9.5.4 Inheritance Fault -- 9.5.5 Strengths and Weaknesses -- 9.6 Key Points -- 9.7 Notes for Experienced Testers.</tableOfContents><tableOfContents>10 Application Testing -- 10.1 Testing Web Applications with User Stories -- 10.2 Example -- 10.2.1 Analysis -- 10.2.2 Test Coverage Items -- 10.2.3 Test Cases -- 10.2.4 Verification of the Test Cases -- 10.3 Test Implementation and Results -- 10.3.1 Implementation -- 10.3.2 Test Results -- 10.4 Application Testing in More Detail -- 10.4.1 System Test Model -- 10.4.2 Application Test Model -- 10.4.3 System Testing and Integration Testing -- 10.4.4 Fault Models for Application Testing -- 10.4.5 Analysis -- 10.4.6 Test Coverage Items -- 10.4.7 Test Cases -- 10.4.8 Implementation -- 10.4.9 Interacting with HTML Elements -- 10.4.10 Test Output Messages -- 10.4.11 Record and Playback Testing -- 10.5 Evaluation -- 10.5.1 Limitations -- 10.5.2 Strengths and Weaknesses -- 10.6 Key Points -- 10.7 Key Differences between Unit Testing and Application Testing -- 10.8 Notes for Experienced Testers -- 11 Test Automation -- 11.1 Introduction -- 11.1.1 Interpreting Test Results -- 11.1.2 Documenting Automated Tests -- 11.1.3 Software Test Automation and Version Control -- 11.2 Test Frameworks: TestNG -- 11.2.1 A Detailed Look at a TestNG Example -- 11.3 Organising Automated Test Code -- 11.3.1 Organising TestNG Tests with an XML File -- 11.4 Setup and Cleanup Methods -- 11.5 Inline Tests vs Parameterised Tests -- 11.6 Test Coverage Measurement -- 11.7 Timeouts -- 11.8 Exceptions -- 11.9 Inheritance Testing -- 11.9.1 Using the Class Name -- 11.9.2 Inheriting Superclass Tests -- 11.9.3 Inheritance Test Selection -- 11.10 Interfacing to Web Applications -- 11.11 Interfacing to Desktop Applications -- 11.12 Interfacing to Mobile Applications -- 12 Random Testing -- 12.1 Introduction to Random Testing -- 12.2 Random Data Selection -- 12.3 Unit Test Example -- 12.3.1 Test Coverage Items -- 12.3.2 Test Cases -- 12.3.3 Test Implementation -- 12.3.4 Test Results.</tableOfContents><tableOfContents>12.4 Application Testing Example.</tableOfContents><note type="statement of responsibility" altRepGroup="00">Ralf Bierig, Maynooth University, Stephen Brown, Maynooth University, Edgar Galván, Maynooth University, Joe Timoney, Maynooth University.</note><note>Title from publisher's bibliographic system (viewed on 19 Aug 2021).</note><note type="bibliography">Includes bibliographical references and index.</note><subject authority="lcsh"><topic>Computer software</topic><topic>Testing.</topic></subject><classification authority="lcc">QA76.76.T48 B54 2022</classification><classification authority="ddc" edition="23">005.14</classification><classification authority="bisacsh">COM051230</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 9781108833349</identifier></relatedItem><relatedItem type="otherFormat"><identifier type="isbn">ISBN 1108833349</identifier></relatedItem><identifier type="isbn">9781108976480</identifier><identifier type="isbn">1108976484</identifier><identifier type="isbn">9781108974073</identifier><identifier type="isbn">1108974074</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">UkCbUP</recordContentSource><recordCreationDate encoding="marc">200804</recordCreationDate><recordChangeDate encoding="iso8601">20210906112358.0</recordChangeDate><recordIdentifier source="kobv">almafu_9961294337402883</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>2</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Test-driven development with Java :</title><subTitle>create higher-quality software by writing tests first with solid and hexagonal architecture /</subTitle></titleInfo><name type="personal" usage="primary"><displayForm>Mellor, Alan,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">enk</placeTerm></place><publisher>Packt Publishing</publisher><dateIssued keyDate="yes">2023</dateIssued><copyrightDate encoding="marc">2022</copyrightDate><edition>1st ed.</edition><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (348 pages)</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Drive development with automated tests and gain the confidence you need to write high-quality software Key Features Get up and running with common design patterns and TDD best practices Learn to apply the rhythms of TDD - arrange, act, assert and red, green, refactor Understand the challenges of implementing TDD in the Java ecosystem and build a plan Book Description Test-driven development enables developers to craft well-designed code and prevent defects. It's a simple yet powerful tool that helps you focus on your code design, while automatically checking that your code works correctly. Mastering TDD will enable you to effectively utilize design patterns and become a proficient software architect. The book begins by explaining the basics of good code and bad code, bursting common myths, and why Test-driven development is crucial. You'll then gradually move toward building a sample application using TDD, where you'll apply the two key rhythms -- red, green, refactor and arrange, act, assert. Next, you'll learn how to bring external systems such as databases under control by using dependency inversion and test doubles. As you advance, you'll delve into advanced design techniques such as SOLID patterns, refactoring, and hexagonal architecture. You'll also balance your use of fast, repeatable unit tests against integration tests using the test pyramid as a guide. The concluding chapters will show you how to implement TDD in real-world use cases and scenarios and develop a modern REST microservice backed by a Postgres database in Java 17. By the end of this book, you'll be thinking differently about how you design code for simplicity and how correctness can be baked in as you go. What you will learn Discover how to write effective test cases in Java Explore how TDD can be incorporated into crafting software Find out how to write reusable and robust code in Java Uncover common myths about TDD and understand its effectiveness Understand the accurate rhythm of implementing TDD Get to grips with the process of refactoring and see how it affects the TDD process Who this book is for This book is for expert Java developers and software architects crafting high-quality software in Java. Test-Driven Development with Java can be picked up by anyone with a strong working experience in Java who is planning to use Test-driven development for their upcoming projects.</abstract><tableOfContents>Cover -- Title Page -- Copyright and Credit -- Dedicated -- Contributors -- Table of Contents -- Preface -- Part 1:  How We Got to TDD -- Chapter 1: Building the Case for TDD -- Writing code badly -- Understanding why bad code is written -- Recognizing bad code -- Bad variable names -- Bad function, method, and class names -- Error-prone constructs -- Coupling and cohesion -- Decreasing team performance -- Diminishing business outcomes -- Summary -- Questions and answers -- Further reading -- Chapter 2: Using TDD to Create Good Code -- Designing good quality code -- Say what you mean, mean what you say -- Take care of the details in private -- Avoid accidental complexity -- Revealing design flaws -- Analyzing the benefits of writing tests before production code -- Preventing logic flaws -- Protecting against future defects -- Documenting our code -- Summary -- Questions and answers -- Further reading -- Chapter 3: Dispelling Common  Myths about TDD -- Writing tests slows me down -- Understanding the benefits of slowing down -- Overcoming objections to tests slowing us down -- Tests cannot prevent every bug -- Understanding why people say tests cannot catch every bug -- Overcoming objections to not catching every bug -- How do you know the tests are right? -- Understanding the concerns behind writing broken tests -- Providing reassurance that we test our tests -- TDD guarantees good code -- Understanding problem-inflated expectations -- Managing your expectations of TDD -- Our code is too complex to test -- Understanding the causes of untestable code -- Reframing the relationship between good design and simple tests -- Managing legacy code without tests -- I don't know what to test until I write the code -- Understanding the difficulty of starting with testing -- Overcoming the need to write production code first -- Summary.</tableOfContents><tableOfContents>Questions and answers -- Further reading -- Part 2:  TDD Techniques -- Chapter 4: Building an Application  Using TDD -- Technical requirements -- Preparing our development environment -- Installing the IntelliJ IDE -- Setting up the Java project and libraries -- Introducing the Wordz application -- Describing the rules of Wordz -- Exploring agile methods -- Reading user stories - the building block of planning -- Combining agile development with TDD -- Summary -- Questions and answers -- Further reading -- Chapter 5: Writing Our First Test -- Technical requirements -- Starting TDD: Arrange-Act-Assert -- Defining the test structure -- Working backward from outcomes -- Increasing workflow efficiency -- Defining a good test -- Applying the FIRST principles -- Using one assert per test -- Deciding on the scope of a unit test -- Catching common errors -- Asserting exceptions -- Only testing public methods -- Preserving encapsulation -- Learning from our tests -- A messy Arrange step -- A messy Act step -- A messy Assert step -- Limitations of unit tests -- Code coverage - an often-meaningless metric -- Writing the wrong tests -- Beginning Wordz -- Summary -- Questions and answers -- Chapter 6: Following the Rhythms of TDD -- Technical requirements -- Following the RGR cycle -- Starting on red -- Keep it simple - moving to green -- Refactoring to clean code -- Writing our next tests for Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 7: Driving Design - TDD  and SOLID -- Technical requirements -- Test guide - we drive the design -- SRP - simple building blocks -- Too many responsibilities make code harder to work with -- Ability to reuse code -- Simplified future maintenance -- Counter-example - shapes code that violates SRP -- Applying SRP to simplify future maintenance -- Organizing tests to have a single responsibility.</tableOfContents><tableOfContents>DIP - hiding irrelevant details -- Applying DI to the shapes code -- LSP - swappable objects -- Reviewing LSP usage in the shapes code -- OCP - extensible design -- Adding a new type of shape -- ISP - effective interfaces -- Reviewing ISP usage in the shapes code -- Summary -- Questions and answers -- Chapter 8: Test Doubles - Stubs and Mocks -- Technical requirements -- The problems collaborators present for testing -- The challenges of testing unrepeatable behavior -- The challenges of testing error handling -- Understanding why these collaborations are challenging -- The purpose of test doubles -- Making the production version of the code -- Using stubs for pre-canned results -- When to use stub objects -- Using mocks to verify interactions -- Understanding when test doubles are appropriate -- Avoiding the overuse of mock objects -- Don't mock code you don't own -- Don't mock value objects -- You can't mock without dependency injection -- Don't test the mock -- When to use mock objects -- Working with Mockito - a popular mocking library -- Getting started with Mockito -- Writing a stub with Mockito -- Writing a mock with Mockito -- Blurring the distinction between stubs and mocks -- Argument matchers - customizing behavior of test doubles -- Driving error handling code with tests -- Testing an error condition in Wordz -- Summary -- Questions and answers -- Further reading -- Chapter 9: Hexagonal Architecture -Decoupling External Systems -- Technical requirements -- Why external systems are difficult -- Environmental problems bring trouble -- Accidentally triggering real transactions from tests -- What data should we expect? -- Operating system calls and system time -- Challenges with third-party services -- Dependency inversion to the rescue -- Generalizing this approach to the hexagonal architecture.</tableOfContents><tableOfContents>Overview of the hexagonal architecture's components -- The golden rule - the domain never connects directly to adapters -- Why the hexagon shape? -- Abstracting out the external system -- Deciding what our domain model needs -- Writing the domain code -- Deciding what should be in our domain model -- Using libraries and frameworks in the domain model -- Deciding on a programming approach -- Substituting test doubles for external systems -- Replacing the adapters with test doubles -- Unit testing bigger units -- Unit testing entire user stories -- Wordz - abstracting the database -- Designing the repository interface -- Designing the database and random numbers adapters -- Summary -- Questions and answers -- Further reading -- Chapter 10: FIRST Tests and the  Test Pyramid -- Technical requirements -- The test pyramid -- Unit tests - FIRST tests -- Integration tests -- What should an integration test cover? -- Testing database adapters -- Testing web services -- Consumer-driven contract testing -- End-to-end and user acceptance tests -- Acceptance testing tools -- CI/CD pipelines and test environments -- What is a CI/CD pipeline? -- Why do we need continuous integration? -- Why do we need continuous delivery? -- Continuous delivery or continuous deployment? -- Practical CI/CD pipelines -- Test environments -- Testing in production -- Wordz - integration test for our database -- Fetching a word from the database -- Summary -- Questions and answers -- Further reading -- Chapter 11: Exploring TDD with  Quality Assurance -- TDD - its place in the bigger quality picture -- Understanding the limits of TDD -- No more need for manual testing? -- Manual exploratory - discovering the unexpected -- Code review and ensemble programming -- User interface and user experience testing -- Testing the user interface -- Evaluating the user experience.</tableOfContents><tableOfContents>Security testing and operations monitoring -- Incorporating manual elements into CI/CD workflows -- Summary -- Questions and answers -- Further reading -- Chapter 12: Test First, Test Later, Test Never -- Adding tests first -- Test-first is a design tool -- Tests form executable specifications -- Test-first provides meaningful code coverage metrics -- Beware of making a code coverage metric a target -- Beware of writing all tests upfront -- Writing tests first helps with continuous delivery -- We can always test it later, right? -- Test-later is easier for a beginner to TDD -- Test-later makes it harder to test every code path -- Test-later makes it harder to influence the software design -- Test-later may never happen -- Tests? They're for people who can't write code! -- What happens if we do not test during development? -- Testing from the inside out -- Testing from the outside in -- Defining test boundaries with hexagonal architecture -- Inside-out works well with the domain model -- Outside-in works well with adapters -- User stories can be tested across the domain model -- Summary -- Questions and answers -- Further reading -- Part 3:  Real-World TDD -- Chapter 13: Driving the Domain Layer -- Technical requirements -- Starting a new game -- Test-driving starting a new game -- Tracking the progress of the game -- Triangulating word selection -- Playing the game -- Designing the scoring interface -- Triangulating game progress tracking -- Ending the game -- Responding to a correct guess -- Triangulating the game over due to too many incorrect guesses -- Triangulating response to guess after game over -- Reviewing our design -- Summary -- Questions and answers -- Further reading -- Chapter 14: Driving the Database Layer -- Technical requirements -- Installing the Postgres database -- Creating a database integration test.</tableOfContents><tableOfContents>Creating a database test with DBRider.</tableOfContents><note type="statement of responsibility" altRepGroup="00">Alan Mellor.</note><note>Includes index.</note><note type="biographical/historical">Mellor Alan: Alan Mellor is an academy lead at BJSS, training the next generation of consulting software engineers, and the author of Java OOP Done Right: Create object-oriented code you can be proud of with modern Java. Alan started with a Sinclair ZX81 computer with 1K of RAM and is very happy to have better computers now. Alan's work includes industrial control in C, web applications for e-commerce, gaming, and banking in Java and Go, and document warehousing in C++. His most visible code is part of Nokia Bounce and the RAF Red Arrows flight simulator if you go back far enough.</note><subject authority="lcsh"><topic>Java (Computer program language)</topic></subject><subject authority="lcsh"><topic>Computer software</topic><topic>Development.</topic></subject><subject authority="lcsh"><topic>Computer software</topic><topic>Testing.</topic></subject><classification authority="lcc">QA76 .M455 2023</classification><classification authority="ddc" edition="23">929.605</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 9781803236230</identifier></relatedItem><relatedItem type="otherFormat"><identifier type="isbn">ISBN 180323623X</identifier></relatedItem><identifier type="isbn">9781803237961</identifier><identifier type="isbn">1803237961</identifier><identifier type="doi">10.0000/9781803237961</identifier><identifier type="oclc">1357534122</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">230204</recordCreationDate><recordChangeDate encoding="iso8601">20230204184834.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9923197706502884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>3</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Foundations of Software Testing :</title><subTitle>For VTU.</subTitle></titleInfo><titleInfo type="alternative"><title>Foundations of Software Testing</title></titleInfo><name type="personal" usage="primary"><displayForm>Mathur, Aditya P.</displayForm></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">xx</placeTerm></place><place><placeTerm type="text">Noida :</placeTerm></place><publisher>Pearson India,</publisher><dateIssued>2010.</dateIssued><dateIssued>©2004.</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2010</dateIssued><edition>1st ed.</edition><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (765 pages)</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Foundations of Software Testing presents sound engineering approaches for software test generation, selection, minimization, assessment, and enhancement. Using numerous examples, it offers a lucid description of a wide range of techniques for a variety of testing-related tasks. Students, practitioners and researchers will find this book an excellent source of simple-to-advanced techniques to use and improve their knowledge of the expertise in software testing.</abstract><tableOfContents>Cover -- Contents -- Preface -- Acknowledgments -- Part I: Preliminaries -- Chapter 1: Basics of Software Testing -- 1.1.Humans, Errors, and Testing -- 1.1.1. Errors, faults, and failures -- 1.1.2. Test automation -- 1.1.3. Developer and tester as two roles -- 1.2 Software Quality -- 1.2.1. Quality attributes -- 1.2.2. Reliability -- 1.3 Requirements, Behavior, and Correctness -- 1.3.1. Input domain and program correctness -- 1.3.2. Valid and invalid inputs -- 1.4 Correctness Versus Reliability -- 1.4.1. Correctness -- 1.4.2. Reliability -- 1.4.3. Program use and the operational profile -- 1.5 Testing and Debugging -- 1.5.1. Preparing a test plan -- 1.5.2. Constructing test data -- 1.5.3. Executing the program -- 1.5.4. Specifying program behavior -- 1.5.5. Assessing the correctness of program behavior -- 1.5.6. Construction of oracles -- 1.6 Test Metrics -- 1.6.1. Organizational metrics -- 1.6.2. Project metrics -- 1.6.3. Process metrics -- 1.6.4. Product metrics: Generic -- 1.6.5. Product metrics: OO software -- 1.6.6. Progress monitoring and trends -- 1.6.7. Static and dynamic metrics -- 1.6.8. Testability -- 1.7 Software and Hardware Testing -- 1.8 Testing and Verification -- 1.9 Defect Management -- 1.10 Execution History -- 1.11 Test-Generation Strategies -- 1.12 Static Testing -- 1.12.1. Walkthroughs -- 1.12.2. Inspections -- 1.12.3. Use of static code analysis tools in static testing -- 1.12.4. Software complexity and static testing -- 1.13 Model-Based Testing and Model Checking -- 1.14 Control-Flow Graph -- 1.14.1. Basic block -- 1.14.2. Flow graph: Definition and pictorial representation -- 1.14.3. Path -- 1.15 Dominators and Postdominators -- 1.16 Program-Dependence Graph -- 1.16.1. Data dependence -- 1.16.2. Control dependence -- 1.17 Strings, Languages, and Regular Expressions -- 1.18 Types of Testing.</tableOfContents><tableOfContents>1.18.1. Classifier C1: Source of test  generation -- 1.18.2. Classifier C2: Life cycle phase -- 1.18.3. Classifier C3: Goal-directed testing -- 1.18.4. Classifier C4: Artifact under test -- 1.18.5. Classifier C5: Test process models -- 1.19 The Saturation Effect -- 1.19.1. Confidence and true reliability -- 1.19.2. Saturation region -- 1.19.3. False sense of confidence -- 1.19.4. Reducing Δ -- 1.19.5. Impact on test process -- Summary -- Bibliographic Notes -- Exercises -- Part II: Test Generation -- Chapter 2: Test Generation from Requirements -- 2.1 Introduction -- 2.2 The Test-Selection Problem -- 2.3 Equivalence Partitioning -- 2.3.1. Faults targeted -- 2.3.2. Relations and equivalence partitioning -- 2.3.3. Equivalence classes for variables -- 2.3.4. Unidimensional versus multidimensional partitioning -- 2.3.5. A systematic procedure for  equivalence partitioning -- 2.3.6. Test selection based on equivalence classes -- 2.3.7. GUI design and equivalence classes -- 2.4 Boundary-Value Analysis -- 2.5 Category-Partition Method -- 2.5.1 Steps in the category-partition method -- 2.6 Cause-Effect Graphing -- 2.6.1. Notation used in cause-effect graphing -- 2.6.2. Creating cause-effect graphs -- 2.6.3. Decision table from cause-effect graph -- 2.6.4. Heuristics to avoid combinatorial explosion -- 2.6.5. Test generation from a decision table -- 2.7 Test Generation from Predicates -- 2.7.1. Predicates and boolean expressions -- 2.7.2. Fault model for predicate testing -- 2.7.2.1 Missing or Extra Boolean Variable Faults -- 2.7.3. Predicate constraints -- 2.7.4. Predicate-testing criteria -- 2.7.5. Generating BOR-, BRO-, and BRE-adequate tests -- 2.7.5 Generating the BOR-constraint set -- Generating the BRO-constraint set -- 2.7.5.3 Generating the BRE-constraint set -- 2.7.5.4 Generating BOR Constraints for Nonsingular Expressions.</tableOfContents><tableOfContents>2.7.6 Cause-effect Graphs and Predicate Testing -- 2.7.7 Fault Propagation -- 2.7.8 Predicate Testing in Practice -- 2.7.8.1 Specification-based Predicate Test Generation -- 2.7.8.2 Program-based Predicate Test Generation -- Summary -- Bibliographic Notes -- Exercises -- Chapter 3: Test Generation from Finite-State Models -- 3.1 Software Design and Testing -- 3.2 Finite-state Machines -- 3.2.1. Excitation using an input sequence -- 3.2.2. Tabular representation -- 3.2.3. Properties of FSM -- 3.3 Conformance Testing -- 3.3.1. Reset inputs -- 3.3.2. The testing problem -- 3.4 A Fault Model -- 3.4.1. Mutants of FSMs -- 3.4.2. Fault coverage -- 3.5 Characterization Set -- 3.5.1. Construction of the k-equivalence partitions -- 3.5.2. Deriving the characterization set -- 3.5.3. Identification sets -- 3.6 The W-method -- 3.6.1. Assumptions -- 3.6.2. Maximum number of states -- 3.6.3. Computation of the transition cover set -- 3.6.4. Constructing Z -- 3.6.5. Deriving a test set -- 3.6.6. Testing using the W-method -- 3.6.7. The error-detection process -- 3.7 The Partial W-method -- 3.7.1. Testing using the Wp-method  for m = n -- 3.7.2. Testing using the Wp-method  for m &gt; n -- 3.8 The UIO-sequence Method -- 3.8.1. Assumptions -- 3.8.2. UIO sequences -- 3.8.3. Core and noncore behavior -- 3.8.4. Generation of UIO sequences -- 3.8.4.1 Explanation of gen-UIO -- 3.8.5. Distinguishing signatures -- 3.8.6. Test generation -- 3.8.7. Test optimization -- 3.8.8. Fault detection -- 3.9 Automata Theoretic Versuscontrol-flow-based Techniques -- 3.9.1. n-switch-cover -- 3.9.2. Comparing automata-theoretic  methods -- Summary -- Bibliographic Notes -- Exercises -- Chapter 4: Test Generation from Combinatorial Designs -- 4.1 Combinatorial Designs -- 4.1.1. Test configuration and test set -- 4.1.2. Modeling the input and configuration spaces.</tableOfContents><tableOfContents>4.2 A Combinatorial Test-Design Process -- 4.3 Fault Model -- 4.3.1. Fault vectors -- 4.4 Latin Squares -- 4.5 Mutually Orthogonal Latin Squares -- 4.6 Pairwise Design: Binary Factors -- 4.7 Pairwise Design: Multivalued Factors -- 4.7.1. Shortcomings of using MOLS  for test design -- 4.8 Orthogonal Arrays -- 4.8.1. Mixed-level orthogonal arrays -- 4.9 Covering and Mixed-Level Covering Arrays -- 4.9.1. Covering arrays -- 4.9.2. Mixed-level covering arrays -- 4.10 Arrays Of Strength &gt;2 -- 4.11 Generating Covering Arrays -- Summary -- Bibliographic Notes -- Exercises -- Chapter 5: Test Selection, Minimization, and Prioritization for Regression Testing -- 5.1 What is Regression Testing? -- 5.2 Regression-Test Process -- 5.2.1. Test revalidation, selection, minimization, and prioritization -- 5.2.2. Test setup -- 5.2.3. Test sequencing -- 5.2.4. Test execution -- 5.2.5. Output comparison -- 5.3 RTS: The Problem -- 5.4 Selecting Regression Tests -- 5.4.1. Test all -- 5.4.2. Random selection -- 5.4.3. Selecting modification-traversing tests -- 5.4.4. Test minimization -- 5.4.5. Test prioritization -- 5.5 Test Selection Using Execution Trace -- 5.5.1. Obtaining the execution trace -- 5.5.2. Selecting regression tests -- 5.5.3. Handling function calls -- 5.5.4. Handling changes in declarations -- 5.6 Test Selection Using Dynamic Slicing -- 5.6.1. Dynamic slicing -- 5.6.2. Computation of dynamic slices -- 5.6.3. Selecting tests -- 5.6.4. Potential dependence -- 5.6.5. Computing the relevant slice -- 5.6.6. Addition and deletion of statements -- 5.6.7. Identifying variables for slicing -- 5.6.8. Reduced dynamic-dependence graph -- 5.7 Scalability of Test-Selection Algorithms -- 5.8 Test Minimization -- 5.8.1. The set-cover problem -- 5.8.2. A procedure for test minimization -- 5.9 Test Prioritization -- 5.10 Tools For Regression Testing -- Summary.</tableOfContents><tableOfContents>Bibliographic Notes -- Exercises -- Part III: Test Adequacy Assessment and Enhancement -- Chapter 6: Test-Adequacy Assessment Using Control Flow and Data Flow -- 6.1 Test Adequacy: Basics -- 6.1.1. What is test adequacy? -- 6.1.2. Measurement of test adequacy -- 6.1.3. Test enhancement using measurements of adequacy -- 6.1.4. Infeasibility and test adequacy -- 6.1.5. Error detection and test enhancement -- 6.1.6. Single and multiple executions -- 6.2 Adequacy Criteria Based on Control Flow -- 6.2.1. Statement and block coverage -- 6.2.2. Conditions and decisions -- 6.2.3. Decision coverage -- 6.2.4. Condition coverage -- 6.2.5. Condition/decision coverage -- 6.2.6. Multiple condition coverage -- 6.2.7. Linear code sequence and jump (LCSAJ) coverage -- 6.2.8. Modified condition/decision coverage -- 6.2.9. MC/DC-adequate tests for compound conditions -- 6.2.10. Definition of MC/DC coverage -- 6.2.11. Minimal MC/DC tests -- 6.2.12. Error detection and MC/DC adequacy -- 6.2.13. Short-circuit evaluation and  infeasibility -- 6.2.14. Tracing test cases to requirements -- 6.3 Data-Flow Concepts -- 6.3.1. Definitions and uses -- 6.3.2. c-use and p-use -- 6.3.3. Global and local definitions and uses -- 6.3.4. Data-flow graph -- 6.3.5. Def-clear paths -- 6.3.6. Def-use pairs -- 6.3.7. Def-use chains -- 6.3.8. A little optimization -- 6.3.9. Data contexts and ordered data contexts -- 6.4 Adequacy Criteria Based on Data Flow -- 6.4.1. c-use coverage -- 6.4.2. p-use coverage -- 6.4.3. all-uses coverage -- 6.4.4. k-dr chain coverage -- 6.4.5. Using the k-dr chain coverage -- 6.4.6. Infeasible c-uses and p-uses -- 6.4.7. Context coverage -- 6.5 Control Flow Versus Data Flow -- 6.6 The Subsumes Relation -- 6.7 Structural and Functional Testing -- 6.8 Scalability of Coverage Measurement -- Summary -- Bibliographic Notes -- Exercises.</tableOfContents><tableOfContents>Chapter 7: Test-Adequacy Assessment Using Program Mutation.</tableOfContents><subject authority="lcsh"><topic>Computer software</topic><topic>Testing.</topic></subject><classification authority="lcc">QA76.76.T48</classification><classification authority="ddc" edition="23/eng/20240520">005.1/4</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 1-299-48672-X</identifier></relatedItem><identifier type="isbn">93-325-0995-6</identifier><identifier type="oclc">842842341</identifier><identifier type="oclc">1434255816</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">210901</recordCreationDate><recordChangeDate encoding="iso8601">20261115165826.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9923197423202884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>4</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Testing JavaScript applications /</title></titleInfo><name type="personal" usage="primary"><displayForm>Da Costa, Lucas,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">nyu</placeTerm></place><place><placeTerm type="text">Shelter Island, New York :</placeTerm></place><publisher>Manning,</publisher><dateIssued>[2021]</dateIssued><dateIssued>©2021</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2021</dateIssued><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (392 pages)</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract>Testing JavaScript Applications teaches you how to implement an automated testing plan for JavaScript-based web applications. Summary Automated testing will help you write high-quality software in less time, with more confidence, fewer bugs, and without constant manual oversight. Testing JavaScript Applications is a guide to building a comprehensive and reliable JS application testing suite, covering both how to write tests and how JS testing tools work under the hood. You'll learn from Lucas de Costa, a core contributor to popular JS testing libraries, as he shares a quality mindset for making testing decisions that deliver a real contribution to your business. You'll benefit from informative explanations and diagrams, easily-transferable code samples, and useful tips on using the latest and most consolidated libraries and frameworks of the JavaScript ecosystem. Purchase of the print book includes a free eBook in PDF, Kindle, and ePub formats from Manning Publications. About the technology Automated testing is essential to delivering good JavaScript applications every time. A complete testing strategy needs to cover functions in isolation, integration between different parts of your code, and correctness from the end user's perspective. This book will teach you how to deliver reliable software quickly and confidently. About the book Testing JavaScript Applications teaches you how to implement an automated testing plan for JavaScript-based web applications. It describes practical testing strategies, covers useful tools and libraries, and explains how to foster a culture of quality. In this clearly-written, example-rich book, you'll explore approaches for both backend and frontend applications and learn how to validate your software much more quickly and reliably. What's inside Unit, end-to-end, and integration testing Managing test cost and complexity Practicing test-driven development Dealing with external dependencies Tools like like Jest and Cypress About the reader For junior JavaScript developers. About the author Lucas da Costa is a core maintainer of Chai and Sinon.JS, two of the most popular testing tools in the JavaScript ecosystem, and contributed to numerous other open-source projects, including Jest. Table of Contents PART 1 - TESTING JAVASCRIPT APPLICATIONS1 An introduction to automated testing2 What to test and when?Part 2 - WRITING TESTS3 Testing techniques4 Testing backend applications5 Advanced backend testing techniques6 Testing frontend applications7 The React testing ecosystem8 Testing React applications9 Test-driven development10 UI-based end-to-end testing11 Writing UI-based end-to-end testsPART 3 - BUSINESS IMPACT12 Continuous integration and continuous delivery13 A culture of quality</abstract><tableOfContents>Intro -- inside front cover -- Testing JavaScript Applications -- Copyright -- dedication -- contents -- front matter -- preface -- acknowledgments -- about this book -- Who should read this book -- How this book is organized: A roadmap -- About the code -- System requirements -- liveBook discussion forum -- about the author -- about the cover illustration -- Part 1. Testing JavaScript applications -- 1 An introduction to automated testing -- 1.1 What is an automated test? -- 1.2 Why automated tests matter -- 1.2.1 Predictability -- 1.2.2 Reproducibility -- 1.2.3 Collaboration -- 1.2.4 Speed -- Summary -- 2 What to test and when? -- 2.1 The testing pyramid -- 2.2 Unit tests -- 2.3 Integration tests -- 2.4 End-to-end tests -- 2.4.1 Testing HTTP APIs -- 2.4.2 Testing GUIs -- 2.4.3 Acceptance tests and end-to-end tests are not the same -- 2.5 Exploratory testing and the value of QA -- 2.6 Tests, cost, and revenue -- Summary -- Part 2. Writing tests -- 3 Testing techniques -- 3.1 Organizing test suites -- 3.1.1 Breaking down tests -- 3.1.2 Parallelism -- 3.1.3 Global hooks -- 3.1.4 Atomicity -- 3.2 Writing good assertions -- 3.2.1 Assertions and error handling -- 3.2.2 Loose assertions -- 3.2.3 Using custom matchers -- 3.2.4 Circular assertions -- 3.3 Test doubles: Mocks, stubs, and spies -- 3.3.1 Mocking imports -- 3.4 Choosing what to test -- 3.4.1 Don't test third-party software -- 3.4.2 To mock, or not to mock: That's the question -- 3.4.3 When in doubt, choose integration tests -- 3.5 Code coverage -- 3.5.1 Automated coverage reports -- 3.5.2 Coverage types -- 3.5.3 What coverage is good for and what it isn't -- Summary -- 4 Testing backend applications -- 4.1 Structuring a testing environment -- 4.1.1 End-to-end testing -- 4.1.2 Integration testing -- 4.1.3 Unit testing -- 4.2 Testing HTTP endpoints -- 4.2.1 Testing middleware.</tableOfContents><tableOfContents>4.3 Dealing with external dependencies -- 4.3.1 Integrations with databases -- 4.3.2 Integrations with other APIs -- Summary -- 5 Advanced backend testing techniques -- 5.1 Eliminating nondeterminism -- 5.1.1 Parallelism and shared resources -- 5.1.2 Dealing with time -- 5.2 Reducing costs while preserving quality -- 5.2.1 Reducing overlap between tests -- 5.2.2 Creating transitive guarantees -- 5.2.3 Turning assertions into preconditions -- Summary -- 6 Testing frontend applications -- 6.1 Introducing JSDOM -- 6.2 Asserting on the DOM -- 6.2.1 Making it easier to find elements -- 6.2.2 Writing better assertions -- 6.3 Handling events -- 6.4 Testing and browser APIs -- 6.4.1 Testing a localStorage integration -- 6.4.2 Testing a History API integration -- 6.5 Dealing with WebSockets and HTTP requests -- 6.5.1 Tests involving HTTP requests -- 6.5.2 Tests involving WebSockets -- Summary -- 7 The React testing ecosystem -- 7.1 Setting up a test environment for React -- 7.1.1 Setting up a React application -- 7.1.2 Setting up a testing environment -- 7.2 An overview of React testing libraries -- 7.2.1 Rendering components and the DOM -- 7.2.2 React Testing Library -- 7.2.3 Enzyme -- 7.2.4 The React test renderer -- Summary -- 8 Testing React applications -- 8.1 Testing component integration -- 8.1.1 Stubbing components -- 8.2 Snapshot testing -- 8.2.1 Snapshots beyond components -- 8.2.2 Serializers -- 8.3 Testing styles -- 8.4 Component-level acceptance tests and component stories -- 8.4.1 Writing stories -- 8.4.2 Writing documentation -- Summary -- 9 Test-driven development -- 9.1 The philosophy behind test-driven development -- 9.1.1 What test-driven development is -- 9.1.2 Adjusting the size of your iterations -- 9.1.3 Why adopt test-driven development? -- 9.1.4 When not to apply test-driven development -- 9.2 Writing a JavaScript module using TDD.</tableOfContents><tableOfContents>9.3 Testing top-down versus testing bottom-up -- 9.3.1 What bottom-up and top-down testing mean -- 9.3.2 How top-down and bottom-up approaches impact a test-driven workflow -- 9.3.3 The pros and cons of bottom-up versus top-down approaches -- 9.4 Balancing maintenance costs, delivery speed, and brittleness -- 9.4.1 Test-driven implementation -- 9.4.2 Test-driven maintenance -- 9.5 Setting up an environment for TDD to succeed -- 9.5.1 Teamwide adoption -- 9.5.2 Keeping distinct lanes -- 9.5.3 Pairing -- 9.5.4 Supplementary testing -- 9.6 TDD, BDD, validations, and specificationsBDD (behavior-driven development) -- Summary -- 10 UI-based end-to-end testing -- 10.1 What are UI-based end-to-end tests? -- 10.2 When to write each type of test -- 10.2.1 UI-based end-to-end tests -- 10.2.2 Pure end-to-end tests -- 10.2.3 Pure UI tests -- 10.2.4 A note on acceptance testing and this chapter's name -- 10.3 An overview of end-to-end testing tools -- 10.3.1 Selenium -- 10.3.2 Puppeteer -- 10.3.3 Cypress -- 10.3.4 When to choose Cypress -- Summary -- 11 Writing UI-based end-to-end tests -- 11.1 Your first UI-based end-to-end tests -- 11.1.1 Setting up a test environment -- 11.1.2 Writing your first tests -- 11.1.3 Sending HTTP requests -- 11.1.4 Sequencing actions -- 11.2 Best practices for end-to-end-tests -- 11.2.1 Page objects -- 11.2.2 Application actions -- 11.3 Dealing with flakiness -- 11.3.1 Avoiding waiting for fixed amounts of time -- 11.3.2 Stubbing uncontrollable factors -- 11.3.3 Retrying tests -- 11.4 Running tests on multiple browsers -- 11.4.1 Using a testing framework to run tests within a browser -- 11.4.2 Running UI-based tests in multiple browsers -- 11.5 Visual regression tests -- Summary -- Part 3. Business impact -- 12 Continuous integration and continuous delivery -- 12.1 What are continuous integration and continuous delivery?.</tableOfContents><tableOfContents>12.1.1 Continuous integration -- 12.1.2 Continuous delivery -- 12.2 The role of automated tests in a CI/CD pipeline -- 12.3 Version-control checks -- Summary -- 13 A culture of quality -- 13.1 Using type systems to make invalid states unrepresentable -- 13.2 Reviewing code to catch problems machines can't -- 13.3 Using linters and formatters to produce consistent code -- 13.4 Monitoring your systems to understand how they actually behave -- 13.5 Explaining your software with good documentation -- Summary -- index -- inside back cover.</tableOfContents><note type="statement of responsibility" altRepGroup="00">Lucas Da Costa.</note><note>Includes index.</note><subject authority="lcsh"><topic>JavaScript (Computer program language)</topic></subject><subject authority="lcsh"><topic>Application software</topic><topic>Development.</topic></subject><classification authority="lcc">QA76.73.J39 .D336 2021</classification><classification authority="ddc" edition="23">005.2762</classification><identifier type="isbn">9781638356394</identifier><identifier type="isbn">1638356394</identifier><identifier type="isbn">9781617297915</identifier><identifier type="isbn">1617297917</identifier><identifier type="oclc">1259321777</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">220204</recordCreationDate><recordChangeDate encoding="iso8601">20261115175646.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9923194523502884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>5</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Discrimination testing in sensory science :</title><subTitle>a practical handbook /</subTitle></titleInfo><name type="personal"><displayForm>Rogers, Lauren,</displayForm><role><roleTerm type="text">editor.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="marcgt">bibliography</genre><genre authority="rdacontent">text</genre><originInfo><place><placeTerm type="code" authority="marccountry">enk</placeTerm></place><place><placeTerm type="text">Duxford, England :</placeTerm></place><publisher>Woodhead Publishing,</publisher><dateIssued>2017.</dateIssued><dateIssued>©2017</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2017</dateIssued><copyrightDate encoding="marc">2017</copyrightDate><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (501 pages) : color illustrations, tables.</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Discrimination Testing in Sensory Science: A Practical Handbook is a one-stop-shop for practical advice and guidance on the performance and analysis of discrimination testing in sensory science. The book covers all aspects of difference testing: the history and origin of different methods, the practicalities of setting up a difference test, replications, the statistics behind each test, dealing with the analysis, action standards, and the statistical analysis of results with R. The book is written by sensory science experts from both academia and industry, and edited by an independent sensory scientist with over twenty years of experience in planning, running and analyzing discrimination tests. This is an essential text for academics in sensory and consumer science and any sensory scientist working in research and development in food, home, and personal care products, new product development, or quality control. Contains practical guidance on the performance and analysis of discrimination testing in sensory and consumer science for both food and non-food products Includes the latest developments in difference testing, including both new methods and state-of-the-art approaches Features extensive coverage of analysis with a variety of software systems Provides essential insight for academics in sensory and consumer science and any sensory scientist working in research and development in food, home, and personal care products, new product development, or quality control</abstract><tableOfContents>Front Cover -- Discrimination Testing in Sensory Science -- Related Titles -- Discrimination Testing in Sensory Science -- Copyright -- Dedication -- Contents -- List of Contributors -- Preface -- Acknowledgments -- I - Introduction to Discrimination Testing -- 1 - Introduction and History of Sensory Discrimination Testing -- REFERENCES -- FURTHER READING -- 2 - Statistics for Use in Discrimination Testing -- 1. BUSINESS RISK -- 1.1 Conventional Hypothesis Testing -- 1.1.1 The p-Value -- 1.1.2 Type I and Type II Errors -- 1.1.3 The Momentary Proportion of Discriminators -- 1.1.4 Sensory Tests for Difference in Tests Without Chance Bounds -- 1.1.5 Statistical Significance Is Not Practical Significance -- 1.1.6 Sensory Tests for Equivalency or Noninferiority -- 1.2 Reframing the Hypothesis Test Using Likelihood or Bayesian Inference -- 2. DATA ARISING FROM SENSORY DISCRIMINATION TEST METHODS -- 2.1 Classification of Methods -- 2.2 Importance of Experimental Design on Analysis -- 3. ANALYSIS OF DATA ARISING FROM TESTS WITH A CHANCE BOUND (E.G., TRIANGLE TEST) -- 3.1 Unreplicated Data -- 3.2 Replicated Data -- 3.3 Statistical Power -- 4. ANALYSIS OF DATA ARISING FROM SIMPLE CLASSIFICATION TASKS WITHOUT A CHANCE BOUND (E.G., A-NOT-A TEST) -- 4.1 Unreplicated Data -- 4.2 Replicated Data -- 4.3 Statistical Power -- 5. ANALYSIS OF DATA ARISING FROM DIFFERENCE FROM CONTROL/DEGREE OF DIFFERENCE TEST METHODS -- 6. ANALYSIS OF DATA ARISING FROM A RANKING TEST METHOD -- 7. EVALUATING SENSORY EQUIVALENCY -- 7.1 Equivalence Testing for Data Arising From Tests With a Correct Response -- 7.2 Equivalence Testing for Data Arising From Tests That Do Not Have a Correct Response -- 8. CONTEXTUALIZING SENSORY DISCRIMINATION RESULTS TO MAKE BUSINESS DECISIONS -- 9. SUMMARY -- 10. RECOMMENDED READING -- ACKNOWLEDGMENTS -- REFERENCES.</tableOfContents><tableOfContents>3 - Deciding Which Test to Use in Discrimination Testing -- 1. THE OBJECTIVE/BUSINESS NEED -- 2. CONSIDERING ALL POSSIBLE TEST METHODS -- 3. GENERATING A HYPOTHESIS -- 4. THE ACTION STANDARD AND POSSIBLE OUTCOMES -- 5. ASSESSORS AND STATISTICAL POWER -- 5.1 Assessor Type -- 5.2 Assessor Numbers -- 5.3 Statistical Power -- 6. BUDGET -- 7. PRODUCT CONSIDERATIONS -- 7.1 Quantity of Sample Available -- 7.2 Carriers/Substrate-Complex Products -- 8. WHEN NOT TO USE DISCRIMINATION TESTING -- 9. SUMMARY -- REFERENCES -- FURTHER READING -- 4 - Applications and Limitations of Discrimination Testing -- 1. INTRODUCTION -- 2. CATEGORIZING DISCRIMINATION TESTS WITHIN SENSORY METHODOLOGY -- 3. APPLICATIONS OF DISCRIMINATION TESTS -- 3.1 Discrimination Testing in Quality Control -- 3.2 Discrimination Testing in Product Development -- 3.3 Other Applications (Special Cases) of Discrimination Tests -- 4. LIMITATIONS OF DISCRIMINATION TESTS -- 5. USING CONSUMERS IN DISCRIMINATION TESTS -- 6. APPLICATIONS AND LIMITATIONS OF COMMONLY USED DISCRIMINATION TESTS -- 6.1 Triangle Test -- 6.1.1 Applications -- 6.1.2 Limitations -- 6.2 Duo-Trio Test -- 6.2.1 Applications -- 6.2.2 Limitations -- 6.3 A-not-A -- 6.3.1 Applications -- 6.3.2 Limitations -- 6.4 Two-Out-of-Five Test -- 6.4.1 Applications -- 6.4.2 Limitations -- 6.5 Paired Comparison Tests -- 6.5.1 2-AFC -- 6.5.2 Same-Different Test -- 6.5.3 Applications -- 6.5.4 Limitations -- 6.6 Tetrad -- 6.6.1 Applications -- 6.6.2 Limitations -- 6.7 Difference From Control -- 6.7.1 Applications -- 6.7.2 Limitations -- 6.8 Ranking -- 6.8.1 Applications -- 6.8.2 Limitations -- 6.9 ABX -- 6.9.1 Applications -- 6.9.2 Limitations -- 7. CONCLUSION -- ACKNOWLEDGMENTS -- REFERENCES -- II - Methods and Analysis in Discrimination Testing: Practical Guidance.</tableOfContents><tableOfContents>5 - Paired Comparison/Directional Difference Test/2-Alternative Forced Choice (2-AFC) Test, Simple Difference Test/ ... -- 1. INTRODUCTION -- 1.1 Overview of the Types of Paired Comparison Test -- 1.2 Application of the Test -- 1.3 Forced Choice Versus Nonforced Choice -- 1.4 Response Bias -- 1.5 One-Sided Versus Two-Sided -- 1.6 Test Sensitivity -- 1.7 Testing Difference Versus Similarity -- 1.8 Replication -- 2. SAME-DIFFERENT TEST: COMPARING TWO SAMPLES -- 2.1 Objective -- 2.2 Method Outline -- 2.3 Example of Questionnaire -- 2.4 Experimental Design -- 2.5 Assessors -- 2.6 Test Environment -- 2.7 Test Protocol -- 2.8 Data Analysis -- 2.9 Case Studies -- 3. DIRECTIONAL PAIRED COMPARISON: COMPARING TWO SAMPLES -- 3.1 Objective -- 3.2 Method Outline -- 3.3 Example of Questionnaire -- 3.4 Experimental Design -- 3.5 Assessors -- 3.6 Test Environment -- 3.7 Test Protocol -- 3.8 Data Analysis -- 3.9 Case Studies -- 4. MULTIPLE PAIRED COMPARISON: COMPARING MULTIPLE SAMPLES -- 4.1 Objective -- 4.2 Method Outline -- 4.3 Example of Questionnaire -- 4.4 Experimental Design -- 4.5 Assessors -- 4.6 Test Environment -- 4.7 Test Protocol -- 4.8 Data Analysis -- 4.9 Case Studies -- REFERENCES -- 6 - A-Not-A Test -- 1. WHAT IS THE A-NOT-A TEST? -- 2. PROCEDURE -- 2.1 Familiarization -- 2.2 Testing -- 2.3 Type of Assessors -- 3. WHEN TO USE THE A-NOT-A TEST -- 4. ANALYSIS OF A-NOT-A RESULTS -- 4.1 Chi-Squared Model -- 4.1.1 Note on Replicated Testing -- 4.2 Thurstonian Distance -- 4.2.1 Decision Rule for the "A-Not-A" -- 4.3 R-Index -- 5. CONCLUSION -- 6. CASE STUDY -- REFERENCES -- FURTHER READING -- 7 - Triangle Test -- 1. TEST PRINCIPLE -- 2. WHY AND WHEN TO USE IT -- 3. ADVANTAGES AND DISADVANTAGES -- 4. TERMS AND DEFINITIONS (BS ISO 4120) -- 4.1 Risks -- 4.1.1 Alpha Risk (α Risk) -- 4.1.2 Beta Risk (β Risk) -- 4.2 N -- 4.3 Pd -- 4.4 Action Standard.</tableOfContents><tableOfContents>5. SETTING UP THE TEST -- 5.1 Panelists' Instructions -- 5.2 Palate Cleansers -- 5.3 "No-Difference" Option -- 5.4 Retasting Products -- 5.5 Additional Information Given to Panelists -- 5.6 Testing Environment -- 5.7 Action Standard -- 6. ASSESSORS -- 6.1 Health -- 6.2 Motivation -- 6.3 Experience Versus Inexperience -- 6.4 Training -- 6.5 Information Given -- 6.6 Number of Assessors to Invite -- 6.7 Replication -- 7. PRODUCT PREPARATION AND SERVING -- 8. TEST LAYOUT -- 8.1 Practical Example of Procedure to Set Up the Test -- 9. ANALYSIS AND REPORTING -- 9.1 Difference Testing -- 9.2 Similarity Testing -- REFERENCES -- FURTHER READING -- 8 - Two-Out-of-Five Test -- 1. INTRODUCTION -- 2. EXPERIMENTAL DESIGN -- 3. DATA ANALYSIS -- 4. ANALYSIS INTERPRETATION -- 5. TWO-OUT-OF-FIVE METHOD IN USE -- 6. HANDY HINTS -- 7. CASE STUDY 1 -- 8. CASE STUDY 2 -- REFERENCES -- 9 - Tetrad Test -- 1. WHY THE UPSURGE IN POPULARITY OF THE TETRAD? -- 2. WHEN TO USE A TETRAD -- 3. SETTING YOUR OBJECTIVE -- 4. ASSESSORS -- 5. SETTING UP THE TEST -- 5.1 Samples -- 5.2 Test Environment -- 5.3 Experimental Design -- 5.4 Test Instructions -- 5.5 Data Analysis and Interpretation -- 5.6 Reporting -- 6. CASE STUDY -- REFERENCES -- 10 - Duo-Trio -- 1. INTRODUCTION -- 2. ORIGIN -- 3. PRINCIPLE OF THE TEST -- 4. ASSESSORS -- 5. FACILITIES AND BEST PRACTICE -- 6. WHY CHOOSE A DUO-TRIO TEST -- 7. DUO-TRIO ADDITIONAL RESEARCH -- 8. STATISTICS-DEFINITIONS -- 9. CASE STUDIES -- REFERENCES -- FURTHER READING -- 11 - Difference From Control (DFC) Test -- 1. METHOD OUTLINE -- 2. WHY AND WHEN TO USE THIS METHOD -- 2.1 Consumer Testing -- 2.2 Quality Control and Quality Assurance -- 2.3 Shelf Life -- 2.4 Nonhomogeneous Samples -- 2.5 Fatigue -- 2.6 Threshold Testing -- 2.7 Product Claims -- 2.8 Screening -- 3. ADVANTAGES -- 4. DISADVANTAGES -- 5. TEST PROCEDURE -- 6. TEST LAYOUT AND SETUP.</tableOfContents><tableOfContents>6.1 Sample Layout and Questionnaire Example -- 6.2 Sample Presentation -- 6.3 Presentation Order -- 6.4 Sample Labeling -- 6.5 Sample Assessment Procedure -- 6.6 Palate Cleanser -- 6.7 Degree of Difference Scale -- 7. ASSESSORS -- 7.1 Assessor Selection -- 7.2 Level of Training Required -- 7.3 Number of Assessors -- 8. NUMBER OF SAMPLES -- 9. PRACTICALITIES -- 10. REPORTING -- 11. CONSTRAINTS -- 12. CASE STUDIES -- REFERENCES -- 12 - Ranking Test -- 1. METHOD OUTLINE -- 2. WHY AND WHEN TO USE THIS METHOD -- 2.1 Trained Panel Testing-Assessment of Sensory Attributes -- 2.1.1 Panel Screening -- 2.1.2 Panel Training -- 2.1.3 Assessment of Panel Performance -- 2.1.4 Sample Assessment -- 2.2 Consumer Testing -- 2.3 Presorting Samples -- 2.4 Effect of Packaging -- 2.5 Threshold Testing -- 2.6 Working With Young Children -- 3. ADVANTAGES -- 4. DISADVANTAGES -- 5. TEST PROCEDURE -- 5.1 Test Layout and Setup -- 5.2 Sample Layout and Questionnaire Example -- 5.3 Sample Presentation -- 5.4 Presentation Order -- 5.4.1 Complete Block Design -- 5.4.2 Balanced Incomplete Block Design -- 5.5 Sample Labeling -- 5.6 Sample Assessment Procedure -- 5.7 Palate Cleanser -- 6. ASSESSORS -- 6.1 Assessor Selection -- 6.2 Level of Training Required -- 6.3 Number of Assessors (BS ISO 8587:2006+A1:2013, 2013) -- 7. NUMBER OF SAMPLES -- 8. PRACTICALITIES -- 9. REPORTING -- 10. CONSTRAINTS -- 11. OTHER USES -- 11.1 Flash Profiling -- 11.2 Rank-Rating -- 12. CASE STUDIES -- REFERENCES -- 13 - ABX Discrimination Task -- 1. INTRODUCTION -- 2. METHOD OUTLINE -- 3. A BRIEF HISTORY -- 4. ADVANTAGES AND DISADVANTAGES OF THE ABX DISCRIMINATION TASK -- 5. ABX DISCRIMINATION TASK METHODOLOGY -- 5.1 Products and Assessors -- 5.2 Experimental Design -- 5.3 Booth Setup and Running the Test -- 5.4 Reducing Carryover Effects Between Samples -- 5.5 To Retest or Not to Retest?.</tableOfContents><tableOfContents>5.6 A Few Practicalities When Running the Test.</tableOfContents><note type="statement of responsibility" altRepGroup="00">edited by Lauren Rogers.</note><note type="bibliography">Includes bibliographical references at the end of each chapters and index.</note><subject authority="lcsh"><topic>Testing</topic><genre>Handbooks, manuals, etc.</genre></subject><subject authority="lcsh"><topic>Sensory discrimination</topic><topic>Testing.</topic></subject><classification authority="lcc">TA410 .D573 2017</classification><classification authority="ddc" edition="23">620.110287</classification><classification authority="ddc">612.8</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 0-08-101009-5</identifier></relatedItem><relatedItem type="series"><titleInfo><title>Woodhead Publishing in food science, technology, and nutrition.</title></titleInfo></relatedItem><identifier type="isbn">0-08-101116-4</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">170727</recordCreationDate><recordChangeDate encoding="iso8601">20240506012508.0</recordChangeDate><recordIdentifier source="kobv">almafu_9960161216002883</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>6</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Software Testing Strategies :</title><subTitle>A Testing Guide for The 2020s /</subTitle></titleInfo><name type="personal" usage="primary"><displayForm>Heusser, Matthew,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><name type="personal"><displayForm>Larsen, Michael,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">enk</placeTerm></place><place><placeTerm type="code" authority="iso3166">PL</placeTerm></place><publisher>Packt Publishing</publisher><dateIssued keyDate="yes">2023</dateIssued><edition>First edition.</edition><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (378 pages)</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Unlock the true potential of software testing to achieve seamless software performance with this comprehensive guide Key Features Gain a solid understanding of software testing and master its multifaceted strategies Empower yourself to effectively overcome software testing challenges Develop actionable real-world testing skills for succeeding in any role Purchase of the print or Kindle book includes a free PDF eBook Book Description Software Testing Strategies covers a wide range of topics in the field of software testing, providing practical insights and strategies for professionals at every level. With equal emphasis on theoretical knowledge and practical application, this book is a valuable resource for programmers, testers, and anyone involved in software development. The first part delves into the fundamentals of software testing, teaching you about test design, tooling, and automation. The chapters help you get to grips with specialized testing areas, including security, internationalization, accessibility, and performance. The second part focuses on the integration of testing into the broader software delivery process, exploring different delivery models and puzzle pieces contributing to effective testing. You'll discover how to craft your own test strategies and learn about lean approaches to software testing for optimizing processes. The final part goes beyond technicalities, addressing the broader context of testing. The chapters cover case studies, experience reports, and testing responsibilities, and discuss the philosophy and ethics of software testing. By the end of this book, you'll be equipped to elevate your testing game and ensure software quality, and have an indispensable guide to the ever-evolving landscape of software quality assurance. What you will learn Explore accessibility, functional testing, performance testing, and more as an integral part of testing Find out how to implement a wide range of testing approaches Develop the skills needed to create effective testing strategies tailored to your project's needs Discover how to prioritize and execute the most impactful test ideas Gain insight into when and how to apply different testing elements Defend your chosen testing strategy with a comprehensive understanding of its components Who this book is for This book is for a broad spectrum of professionals engaged in software development, including programmers, testers, and DevOps specialists. Tailored to those who aspire to elevate their testing practices beyond the basics, the book caters to anyone seeking practical insights and strategies to master the nuanced interplay between human intuition and automation. Whether you are a seasoned developer, meticulous tester, or DevOps professional, this comprehensive guide offers a transformative roadmap to become an adept strategist in the dynamic realm of software quality assurance.</abstract><tableOfContents>Cover -- Title Page -- Copyright -- Dedication -- Contributors -- Table of Contents -- Preface -- Part 1: The Practice  of Software Testing -- Chapter 1: Testing and Designing Tests -- Jumping into testing -- The impossibility of complete testing -- What is the EVP asking for? -- Toward a theory of error -- Testing software - an example -- Testing software - an analysis -- Quick attacks - the airdropped tester -- Test design - input space coverage -- Equivalence classes and boundaries -- Decision tables -- Decision trees -- All-pairs and pairwise testing -- High volume automated approaches -- Other approaches -- Data and predictability - the oracle problem -- Summary -- Further reading -- Chapter 2: Fundamental Issues in Tooling and Automation -- Technical requirements -- No silver bullets - you can't radically fix the test cycle -- The minefield regression problem -- Coverage model -- The Battleships problem - testing versus checking -- Comparing Battleships to bugs -- Automation rarely beats human intuition -- The maintenance problem -- The dangers of comprehensive tests -- The money problem -- Lessons from the fundamental issues -- Summary -- Chapter 3: Programmer-Facing Testing -- Technical requirements -- The programmer's view -- Testing and reliability -- The hexagonal architecture -- Introducing FizzBuzz -- Unit tests -- TDD -- Consequences of TDD -- Unit test and unit code design -- Using test doubles to create seams -- Mutation testing -- Web APIs from a test perspective -- Web API testing strategy -- Testing functional and legacy code -- A Roman Numerals Kata -- Summary -- Chapter 4: Customer-Facing Tests -- Technical requirements -- A word of warning -- Human Or Tooling-is it either/or? -- GUI test automation patterns -- Eliminating redundancy with domain-specific libraries -- Eliminating redundancy through object locators.</tableOfContents><tableOfContents>Do you need conditionals, looping structures, and variables? -- The tradeoff between assertion and image recognition -- Designing your own system -- Toward specification by example -- Specification by example -- Low-code and no-code test automation -- Batch- and model-driven test automation -- This chapter is completely wrong -- Summary -- Chapter 5: Specialized Testing -- Technical requirements -- Understanding load and performance testing -- Getting to know the basics of load testing -- Setting up a load test -- Exploring security testing -- Security concepts -- Checking out common security vulnerabilities -- Learning about industry standards -- Investigating some security testing tools -- Delving into accessibility testing -- What is accessibility? -- Advocating for accessibility -- Investigating the distinctions between accessibility and inclusive design -- Learning about the WCAG standard -- Investigating some accessibility testing tools -- Internationalization and localization -- Preparing for internationalization and localization -- Investigating tools for internationalization and localization -- CI -- CI and the pipeline -- Getting involved with build management as a tester -- Investigating CI tools -- Regulated testing -- Navigating regulatory requirements -- Summary -- Chapter 6: Testing Related Skills -- Technical requirements -- Finding bugs -- Oracles in software testing -- Inattentional blindness and Oracles -- About the word bug -- Writing bug reports -- Effective bug reports -- Effective reproduction steps -- Planning testing - cases and plans -- Test cases in practice -- Metrics and measurement -- Metric dysfunction -- Project projections -- Influencing change -- Summarizing information -- Summary -- Chapter 7: Test Data Management -- Technical requirements -- The test data problem -- Test data and database apps.</tableOfContents><tableOfContents>The standard data seed -- Table-driven - when test data drives behavior -- Scriptable users and structure -- Exploring synthetic users -- Leveraging production refreshes -- Exploring development, test, and production environments -- Understanding the regulatory issues in test data management -- The user spy feature -- Summary -- Part 2: Testing and  Software Delivery -- Chapter 8: Delivery Models and Testing -- Technical requirements -- Waterfall -- The advantages of and place for the waterfall -- The V-Model -- Iterative, incremental, and mini waterfalls -- Extreme Programming (XP) -- The context of XP -- Scrum and SAFe -- The context of Scrum -- SAFe and its context -- House-rules software development -- The Agile Manifesto -- Context-driven testing -- Illustrations of the principles in action -- Kanban as a house rule -- Continuous delivery and deployment -- DevOps, Platform Engineering, SRE -- Summary -- Further reading -- Chapter 9: The Puzzle Pieces of Good Testing -- Technical requirements -- Recipes - how to do hard things -- Defining recipes -- Shouldn't recipes just be automated? -- Do recipes overlap with technical documentation? -- Coverage - did we test the right things well enough? -- Precise code coverage measures -- Closing out coverage -- Defects - what is the status of the software? -- Schedule and risk - too many test ideas, not enough time -- Iterative testing -- Strategy - what are our risks and priorities? -- Dashboard - how do we communicate what we know? -- Summary -- Chapter 10: Putting Your  Test Strategy Together -- What are we doing now? -- Getting the form filled out -- The elevator pitch -- A census of risk -- Defining a real risk census -- Setting priorities, time management, and scope -- Today's strategy versus tomorrow's goals -- Summary -- Chapter 11: Lean Software Testing -- Lean software testing defined.</tableOfContents><tableOfContents>From ideas in practice to the term "Lean" -- The seven wastes -- Waste #1 - transport -- Waste #2 - inventory -- Waste #3 - motion -- Waste #4 - waiting -- Waste #5 - overprocessing -- Waste #6 - overproduction -- Waste #7 - defects -- (New) waste #8 - ability -- Removing waste in testing -- Flow -- Visualizing flow - an example -- Multitasking -- Measurement - lead time versus cycle time -- Efficiency and congestion -- Metric - touch time -- Batch size -- Queues and efficiency -- Arrival time pacing -- Limiting work in progress to create a pull system -- Release cadence -- One-piece flow and CD -- Summary -- Part 3: Practicing  Politics -- Chapter 12: Case Studies and Experience Reports -- RCRCRC at scale -- The 1-day test plan -- RCRCRC in the enterprise -- A coverage dashboard -- Test coverage blinders -- Pair and tri-programming -- Discovering the expertise paradox -- Making expertise transparent -- The evolution of the test strategy -- The alternative to evolution - information hiding -- Professional pushback - dealing with bullies -- Power in the workplace -- One way to say it -- Boundaries in the enterprise -- Narcissistic communication -- Boundary enforcement - the power move -- If you choose to stay -- Summary -- Chapter 13: Testing Activities or a Testing Role? -- Technical requirements -- The cultural conflict with a testing role -- How we got here - the bad news -- How we got here - developing at internet speed -- Building a risk mitigation team -- The purpose of the risk exercise -- Faith-based versus empirical test automation -- The math behind faith-based test automation -- Possible outcomes -- Shift left and shift right -- (Actually) continuous testing -- Summary -- Chapter 14: Philosophy and Ethics in Software Testing -- Philosophy and why it matters in testing -- Sprint Length: it depends -- Shu Ha Ri: learning by osmosis.</tableOfContents><tableOfContents>A tough question: what do you want? -- Ethics and ethical reasoning in testing -- Ethical frameworks -- Classic ethical challenges -- Practical ethical issues in testing -- Skipping test steps and the good news -- Decisions are not made in meetings -- Scientific thinking and logical fallacies -- Logical fallacies -- How we wind up in hell and how to escape -- Put the responsibility in the right place -- Summary -- Additional readings for the serious philosopher -- Chapter 15: Words and Language About Work -- Context-driven testing and the other schools -- The Agile school -- The DevOps or CD school -- The analytical school -- The factory school -- The quality school -- The context-driven school -- Precise language -- Wordsmatter -- The benefits of being imprecise -- Process versus skill -- Testing and checking -- Yes, we can assure quality -- Summary -- Further reading -- Chapter 16: Testing Strategy Applied -- A mobile test strategy example -- Our sample mobile app -- Designing a test program -- Mobile system coordination and deployment -- The human element -- AI in software testing -- The state of AI tools -- Possible ways to use AI for testing -- Other forms of AI in testing -- The bottom line for AI testing -- A few thoughts to leave with -- Thoughts on documentation -- Summary -- Index -- About PACKT -- Other Books You May Enjoy.</tableOfContents><note type="statement of responsibility" altRepGroup="00">Matthew Heusser and Michael Larsen.</note><note>Description based upon print version of record.</note><note>Investigating tools for internationalization and localization</note><note type="biographical/historical">Heusser Matthew: Matt Heusser is the Managing Director at Excelon Development, where he specializes in Software Delivery, DevOps, and Testing across diverse industries such as software, fintech, and automotive. With a Master's degree from Grand Valley State University and a remarkable track record, Matt has earned international recognition through awards and delivered keynote speeches that have left lasting impressions. Matt's legacy in the tech world includes pioneering the world's first multi-user distributed spreadsheet, a groundbreaking innovation that predates even Google Sheets. His expertise extends to project rescue initiatives, including one initiated by BMW's board of directors, where he demonstrated his exceptional leadership and problem-solving skills. In addition to his hands-on contributions, Matt has effectively managed API test development teams and provided invaluable support to developers. Matt Heusser's career is a testament to his unwavering commitment to pushing the boundaries of technology, delivering outstanding results, and inspiring the next generation of innovators in the software and technology landscape. Larsen Michael: Over the past decade, Michael has been actively engaged in the realm of software testing, focusing on audits and testing fixes in alignment with U. S. Section 508 and E. U. WCAG accessibility standards. His commitment extends beyond testing, as he is equally passionate about promoting accessibility and inclusive design through talks and training sessions. Michael leverages a diverse set of tools, including Axe, Lighthouse, Wave, VoiceOver, JAWS, NVDA, ColorContrast Analyzer, among others, to facilitate the accessibility testing process. He has played a pivotal role in urging organizations to prioritize accessibility considerations in their software development and testing endeavors. Moreover, Michael possesses a knack for uncovering issues within systems, collaborating with developers to rectify them, and assisting customers in devising innovative solutions. His overarching mission is to nurture and lead top-notch testers and test teams, fostering a culture of excellence in the field. With an extensive career spanning three decades, Michael has lent his expertise to various product domains and industries, encompassing network routers and switches, virtual machines, capacitance touch devices, video games, and a wide spectrum of client/server, distributed database, and web applications. Beyond his software testing endeavors, Michael boasts an impressive array of achievements and affiliations. He holds a Black Belt certification from the Miagi-Do School of Software Testing, co-founded and facilitates the Americas chapter of Weekend Testing, serves as a director for the Association for Software Testing (AST), leads instruction for the Black Box Software Testing courses offered by AST, curates training materials for the SummerQAmp initiative, and currently holds a position on the board of the Pacific Northwest Software Quality Conference (PNSQC).</note><subject authority="lcsh"><topic>Computer software</topic><topic>Testing.</topic></subject><classification authority="lcc">QA76 .H487 2023</classification><classification authority="ddc" edition="23">929.605</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 9781837638024</identifier></relatedItem><relatedItem type="otherFormat"><identifier type="isbn">ISBN 1837638020</identifier></relatedItem><identifier type="isbn">9781837637850</identifier><identifier type="isbn">1837637857</identifier><identifier type="doi">10.0000/9781837637850</identifier><identifier type="oclc">1412621269</identifier><identifier type="oclc">1437998909</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">231214</recordCreationDate><recordChangeDate encoding="iso8601">20231214134736.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9923194914102884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>7</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Agile testing :</title><subTitle>the agile way to quality /</subTitle></titleInfo><titleInfo type="uniform"><title>Agile Weg zur Qualität. English</title></titleInfo><name type="personal"><displayForm>Baumgärtner, Manfred,</displayForm><role><roleTerm type="text">author.</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="thub">Llibres electrònics</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">sz</placeTerm></place><place><placeTerm type="text">Cham, Switzerland :</placeTerm></place><publisher>Springer International Publishing,</publisher><dateIssued>[2021]</dateIssued><dateIssued>©2021</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2021</dateIssued><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (xxv, 257 pages) : illustrations</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">This book is written by testers for testers. In ten chapters, the authors provide answers to key questions in agile projects. They deal with cultural change processes for agile testing, with questions regarding the approach and organization of software testing, with the use of methods, techniques and tools, especially test automation, and with the redefined role of the tester in agile projects. The first chapter describes the cultural change brought about by agile development. In the second chapter, which addresses agile process models such as Scrum and Kanban, the authors focus on the role of quality assurance in agile development projects. The third chapter deals with the agile test organization and the positioning of testing in an agile team. Chapter 4 discusses the question of whether an agile tester should be a generalist or a specialist. In Chapter 5, the authors turn to the methods and techniques of agile testing, emphasizing the differences from traditional, phase-oriented testing. In Chapter 6, they describe which documents testers still need to create in an agile project. Next, Chapter 7 explains the efficient use of test automation, which is particularly important in agile development, as it is the main instrument for project acceleration and is necessary to support state-of-the-art DevOps approaches and Continuous Integration. Chapter 8 then adds examples from test tool practice extending test automation to include test management functionality. Chapter 9 is dedicated to training and its importance, emphasizing the role of employee training in getting started with agile development. Finally, Chapter 10 summarizes the results of the agile journey in general with a special focus on testing. To make the aspects described even more tangible, the specific topics of this book are accompanied by the description of experiences from concrete software development projects of various organizations. The examples demonstrate that different approaches can lead to solutions that meet the specific challenges of agile projects.</abstract><tableOfContents>Intro -- Foreword -- Preface -- Practical Examples -- Acknowledgments -- Contents -- About the Authors -- 1: Agile: A Cultural Change -- 1.1 The Journey to Agile Development -- 1.2 The Reasons for Agile Development -- 1.3 The Significance of the Agile Manifesto for Software Testing -- 1.4 Agile Requires a Cultural Change Among the Users -- 1.5 Consequences of Agile Development for Software Quality Assurance -- 1.5.1 Spatial Consequences -- 1.5.2 Time-Related Consequences -- Project EMIL: Cultural Change-What Agile Means -- 2: Agile Process Models and Their View on Quality Assurance -- 2.1 Challenges in Quality Assurance -- 2.1.1 Quality and Deadline -- 2.1.2 Quality and Budget -- 2.1.3 The Importance of Software Testing -- 2.1.4 Technical Debt -- 2.1.5 Test Automation -- 2.1.6 Hierarchical Mindset -- 2.2 Importance of the Team -- Project EMIL: Mindset: The Team Is Born -- 2.3 Audits for Quality Assurance in Agile Projects -- 2.3.1 Scrum -- 2.3.1.1 Sprint Review Meeting -- 2.3.1.2 Sprint Retrospective -- Project EMIL: A Retrospective -- 2.3.2 Kanban -- 2.3.2.1 Kaizen: Continuous Improvement -- 2.4 Continuous Integration -- 2.5 Lean Software Development -- 3: Organization of the Software Test in Agile Projects -- 3.1 Positioning of Test in Agile Projects -- 3.1.1 The Fundamental Test Process According to ISTQB -- 3.1.1.1 Test Planning, Monitoring, and Control -- 3.1.1.2 Test Analysis and Test Design -- 3.1.1.3 Test Implementation and Test Execution -- 3.1.1.4 Evaluating Exit Criteria and Reporting -- 3.1.1.5 Test Closure Activities -- 3.1.2 Which Test for What Purpose: The Four Test Quadrants of Agile Testing -- 3.1.2.1 First Quadrant: Technology-Oriented and Team-Supporting -- 3.1.2.2 Second Quadrant: Business-Oriented and Team-Supporting -- 3.1.2.3 Third Quadrant: Business-Oriented and Critique the Product.</tableOfContents><tableOfContents>3.1.2.4 Fourth Quadrant: Technology-Oriented and Critique the Product -- 3.1.2.5 The Context -- 3.1.3 Tips for Software Testing from an Agile Perspective -- 3.1.4 Scaled Agile with SAFe or LeSS -- 3.1.4.1 Testing with SAFe -- 3.1.4.2 Testing with LeSS -- 3.1.5 Scalable Organization of Agile Teams -- 3.2 Practical Examples -- 3.2.1 The Role of the Tester and the Transition to ``Quality Specialist´´ at Otto.de: A Progress Report -- 3.2.2 Acceptance Test as a Separate Scrum Project/Scrum Team -- 3.2.3 Test Competence Center for Agile Projects -- 3.2.4 A Team Using the V-Model in a Health Care Environment -- Project EMIL: Definition of Done -- 4: Role of Testers in Agile Projects -- 4.1 Generalist Versus Specialist -- 4.2 The Path from the Central Test Center to the Agile Team -- 4.2.1 Tester Involvement in Traditional Teams -- 4.2.2 Approaches for Tester Integration in Agile Teams -- 4.2.2.1 The Switch from Traditional to Agile -- Hint -- 4.2.2.2 Increase in Efficiency and Effectiveness -- Pair Testing -- 4.2.2.3 Team Composition -- Practice -- Project EMIL: Role of the Tester and Quality Management -- 4.3 Challenges for Testers in the Team -- 4.3.1 Testers in the Agile Team -- 4.3.1.1 The Quality Coach -- 4.3.1.2 Tasks of Agile Testers -- 4.3.2 Timely Problem Detection -- 4.3.3 The Emergence of Technical Debts -- 4.4 Agile Teams and Testers Working Against ``Technical Debt´´ -- 4.4.1 What Is ``Technical Debt´´? -- 4.4.2 Dealing with Technical Debt -- 4.5 Experience Report: Quality Specialist at Otto.de -- 4.5.1 We Act as the Team´s Quality Coach -- 4.5.2 We Accompany the Entire Life Cycle of Each Story -- 4.5.3 We Operate Continuous Delivery/Continuous Deployment -- 4.5.4 We Balance the Different Types of Tests in the Test Pyramid -- 4.5.5 We Help the Team to Use the Right Methods for High Quality -- 4.5.6 We Are Active in Pairing.</tableOfContents><tableOfContents>4.5.7 We Represent Different Perspectives -- 4.5.8 We Are Communication Talents -- 4.5.9 We Are Quality Specialists -- 4.6 The Challenge of Change -- 4.6.1 Starting Position -- 4.6.2 Supporting and Challenging Factors on the Way to Agile Development -- 4.6.2.1 Creativity and Flexibility -- 4.6.2.2 Stuck in Old Thought Patterns -- 4.6.2.3 Sluggishness and Lack of Flexibility -- 4.6.2.4 Work Environment -- 4.6.2.5 Changing Roles of Senior Testers/Senior Managers -- 4.7 Helpful Tips from Project and Community Experience -- 5: Agile Test Management, Methods, and Techniques -- 5.1 Test Management -- 5.1.1 Test Planning in a Traditional Environment -- Note -- 5.1.2 Test Planning in an Agile Environment -- Note -- 5.1.3 Test Plan -- Practice -- 5.1.4 Test Activities in Iteration Zero: Initialization Sprint -- 5.1.5 External Support for Test Planning -- 5.1.6 Test Estimation -- 5.1.7 Test Organization -- 5.1.8 Test Creation, Implementation, and Release -- 5.2 Test Methods in an Agile Environment -- 5.2.1 Risk-Based and Value-Based Testing -- Note -- 5.2.2 Exploratory Testing -- 5.2.3 Session-Based Testing -- Note -- 5.2.4 Acceptance Test-Driven Development -- 5.2.5 Test Automation -- 5.3 Significant Factors Influencing Agile Testing -- 5.3.1 Continuous Integration (CI) -- 5.3.2 Automated Configuration Management -- 5.4 The Special Challenges of Testing of IoT -- 5.4.1 What Is the Internet of Things? -- 5.4.2 The Challenge of Testing IoT in Agile Teams -- 6: Agile Testing Documentation -- 6.1 The Role of Documentation in Software Development -- 6.2 The Benefits of Documentation -- Project EMIL: (Test) Documentation -- 6.3 Documentation Types -- 6.3.1 Requirements Documentation -- 6.3.2 Code Documentation -- 6.3.3 Test Documentation -- 6.3.3.1 Test Case Description -- 6.3.3.2 Test Execution Documentation -- 6.3.3.3 Test Coverage -- Project EMIL: Metrics.</tableOfContents><tableOfContents>6.3.3.4 Defect Documentation -- Project EMIL: Defect Management -- 6.3.4 User Documentation -- 6.4 The Tester as a Documenter -- 6.5 Importance of Documentation in Agile Testing -- 7: Agile Test Automation -- 7.1 The Trouble with Tools in Agile Projects -- 7.2 Test Automation: How to Approach It? -- Project EMIL: Test Automation -- 7.3 Test Automation with Increasing Software Integration -- 7.3.1 Unit Test/Component Test -- 7.3.2 Component Integration Test -- 7.3.3 System Test -- 7.3.4 System Integration Test -- 7.4 xUnit Frameworks -- Practice: Measuring Test Case Coverage -- Practice: Local Test Environment Using the Integration Test Environment -- 7.5 Use of Placeholders -- 7.6 Integration Server -- 7.7 Test Automation in Business-Oriented Testing -- Hint: Test Automation Only for User Interfaces? -- 7.7.1 Test Automation Frameworks -- 7.7.2 Agile Versus Traditional Automation of User Interactions -- 7.7.2.1 Agile Test Automation -- 7.7.2.2 Traditional Test Automation -- 7.7.3 A Typical Example: FitNesse and Selenium -- Note: Fixture Types -- 7.7.4 Behavior-Driven Development with Cucumber and Gherkin -- 7.8 Test Automation in Load and Performance Testing -- 7.9 The Seven Worst Ideas for Test Automation -- 7.9.1 Expecting Success After Just a Few Sprints -- 7.9.2 Trusting Test Tools Blindly -- 7.9.3 Considering Writing the Test Scripts as a Secondary Job -- 7.9.4 Burying the Test Data in Test Cases -- 7.9.5 Associating the Test Automation Only with UI Tests -- 7.9.6 Underestimating the Comparison with Expected Results -- 7.9.7 Accepting the (Un)testability of the Application -- 8: Use of Tools in Agile Projects -- 8.1 Project Management -- 8.1.1 Broadcom Rally -- 8.2 Requirements Management -- 8.2.1 Polarion QA/ALM -- 8.3 Defect Management -- 8.3.1 The Bug Genie -- 8.3.2 Atlassian JIRA -- 8.4 Test Planning and Control -- 8.4.1 Atlassian JIRA.</tableOfContents><tableOfContents>8.5 Test Analysis and Test Design -- 8.5.1 Risk-Based Testing in the Tosca Test Suite -- 8.6 Test Implementation and Test Execution -- 8.6.1 Microsoft Test Manager -- 9: Education and Its Importance -- 9.1 ISTQB Certified Tester -- 9.2 Practitioner in Agile Quality (PAQ) -- 9.2.1 Motivation -- 9.2.2 Training Content -- 9.3 ISTQB Certified Tester Foundation Level Extension Agile Tester -- 9.4 Individual Trainings (Customized Trainings) -- 9.4.1 Recommended Approach for the Introduction of Agility -- 9.4.1.1 Inventory of the Actual Situation -- 9.4.1.2 Dependency Analysis -- 9.4.1.3 Define the ``New´´ Goal -- 9.4.2 Organization -- 9.4.3 Pilot Phase -- 9.4.4 Rollout in the Organization -- Hint -- 10: Retrospective -- References -- Index.</tableOfContents><note type="statement of responsibility" altRepGroup="00">Manfred Baumgartner [and five others].</note><note type="bibliography">Includes bibliographical references and index.</note><subject authority="lcsh"><topic>Computer software</topic><topic>Testing.</topic></subject><subject authority="lcsh"><topic>Agile software development.</topic></subject><subject authority="thub"><topic>Programació (Ordinadors)</topic></subject><subject authority="thub"><topic>Desenvolupament de programari.</topic></subject><classification authority="lcc">QA76.76.T48 .A355 2021</classification><classification authority="ddc" edition="23">005.14</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 3-030-73208-8</identifier></relatedItem><identifier type="isbn">3-030-73209-6</identifier><identifier type="oclc">1268112554</identifier><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">220616</recordCreationDate><recordChangeDate encoding="iso8601">20240708142959.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9922308018302884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>8</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>Medical Tests Sourcebook, 7th Ed.</title></titleInfo><name type="personal" usage="primary"><displayForm>Chambers, James.</displayForm></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">text</genre><genre authority="4">Electronic books.</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">xx</placeTerm></place><place><placeTerm type="text">Detroit :</placeTerm></place><publisher>Infobase Holdings, Inc.,</publisher><dateIssued>2021.</dateIssued><dateIssued>©2021.</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2021</dateIssued><edition>7th ed.</edition><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (818 pages)</extent><form type="media" authority="rdamedia">computer</form><form type="carrier" authority="rdacarrier">online resource</form></physicalDescription><abstract type="Summary">Provides basic consumer health information about endoscopic, imaging, laboratory, and other types of medical testing for disease diagnosis and monitoring, along with guidelines for screening and preventive care testing in children and adults.</abstract><tableOfContents>Intro -- Table of Contents -- Preface -- Part 1-Screening and Preventive Care Tests -- Chapter 1-Regular Health Exams -- Section 1.1-Why Regular Health Exams Are Important -- Section 1.2-Women: Stay Healthy at Any Age -- Section 1.3-Men: Take Charge of Your Health -- Chapter 2-Family History -- Chapter 3-Newborn Screening Tests -- Chapter 4-Preventive Care Screening Tests for Children and Adolescents -- Section 4.1-Checkup for Babies - Ages 0 to 11 Months -- Section 4.2-Checkup for Children - Ages 1 to 4 -- Section 4.3-Checkup for Children - Ages 5 to 10 -- Section 4.4-Checkup for Children - Ages 11 to 14 -- Section 4.5-Checkup for Children - Ages 15 to 17 -- Section 4.6-Body Mass Index Screening for Weight Problems -- Section 4.7-Screening Test for Child's Vision -- Section 4.8-Get Your Teen Screened for Depression -- Chapter 5-Preventive Care and Screening Tests for Adults -- Section 5.1-Women's Health Screening Recommendations -- Section 5.2-Men's Health Screening Recommendations -- Section 5.3-Get Your Blood Pressure Checked -- Section 5.4-Diabetes -- Section 5.5-Get Tested for Cholesterol -- Section 5.6-Depression -- Section 5.7-Hearing Tests -- Section 5.8-Vision Test -- Section 5.9-Testing for COVID-19 -- Section 5.10-Get Tested for Sexually Transmitted Disease -- Section 5.11-Recommended Immunizations for Seniors -- Section 5.12-Fall Risk Assessment -- Chapter 6-Genetic Testing -- Section 6.1-Frequently Asked Questions about Genetic Testing -- Section 6.2-Genetic Consultation -- Section 6.3-Genetic Testing for Breast Cancer Risk -- Chapter 7-Required Medical Screening of Immigrants to the United States -- Part 2-Laboratory Tests -- Chapter 8-Understanding Laboratory Tests -- Chapter 9-Blood Tests -- Section 9.1-Common Blood Tests -- Section 9.2-Biochemical Analysis -- Section 9.3-Hematological Analysis.</tableOfContents><tableOfContents>Section 9.4-Microbial Diagnosis of Bloodstream Infection -- Section 9.5-Immunological Tests -- Chapter 10-Surgical Pathology -- Section 10.1-Bone Marrow Tests -- Section 10.2-Lumbar Puncture -- Section 10.3-Cytology -- Section 10.4-Biopsy -- Chapter 11-Types of Biopsies -- Section 11.1-Breast Biopsy -- Section 11.2-Kidney Biopsy -- Section 11.3-Liver Biopsy -- Section 11.4-Sentinel Lymph Node Biopsy -- Section 11.5-Other Biopsies -- Chapter 12-Urine Tests -- Section 12.1-Urine Test: Basics -- Section 12.2-Mucus in Urine -- Section 12.3-Glucose in Urine -- Section 12.4-Blood in Urine -- Section 12.5-Crystals in Urine Test -- Chapter 13-Stool Tests -- Section 13.1-Stool Culture -- Section 13.2-Detecting Parasite Antigens -- Section 13.3-Fecal Occult Blood Test -- Chapter 14-Yeast Infection Test -- Chapter 15-Drug Testing -- Part 3-Imaging Tests -- Chapter 16-Medical Imaging: Benefits and Risks -- Chapter 17-Medical X-rays -- Section 17.1-Medical X-rays - Basics -- Section 17.2-Chest X-ray -- Section 17.3-Dental Imaging -- Section 17.4-Bone Density Scan -- Section 17.5-Fluoroscopy -- Section 17.6-Pediatric X-ray Imaging -- Section 17.7-Mammograms -- Chapter 18-Contrast Radiography -- Section 18.1-Coronary Angiography -- Section 18.2-Cystogram -- Section 18.3-Upper Gastrointestinal Series -- Section 18.4-Lower Gastrointestinal Series (Barium Enema) -- Section 18.5-Lung Ventilation/Perfusion Scan -- Chapter 19-Ultrasound (Sonography) Exams -- Section 19.1-Ultrasound Overview -- Section 19.2-Carotid Ultrasound -- Section 19.3-Echocardiography (Heart) -- Section 19.4-Pelvic Ultrasound -- Section 19.5-Abdominal Ultrasound -- Chapter 20-Computed Tomography -- Section 20.1-Introduction to Computed Tomography -- Section 20.2-Chest CT Scan -- Section 20.3-Full Body CT Scans - What You Need to Know -- Chapter 21-Magnetic Resonance Imaging.</tableOfContents><tableOfContents>Chapter 22-Nuclear Imaging -- Chapter 23-Neurological Imaging -- Chapter 24-Optical Imaging -- Part 4-Endoscopic, Catheterization, and Electrical Tests and Assessments -- Chapter 25-Endoscopy -- Section 25.1-Endoscopy Overview -- Section 25.2-Bronchoscopy -- Section 25.3-Capsule Endoscopy -- Section 25.4-Colonoscopy -- Section 25.5-Virtual Colonoscopy -- Section 25.6-Cystoscopy and Ureteroscopy -- Section 25.7-Upper Endoscopy -- Section 25.8-Laryngoscopy -- Section 25.9-Flexible Sigmoidoscopy -- Section 25.10-Endoscopic Retrograde Cholangiopancreatography -- Section 25.11-Diagnostic Laparoscopy -- Chapter 26-Cardiac Catheterization -- Chapter 27-Transesophageal Echocardiography -- Chapter 28-Electrocardiogram -- Chapter 29-Stress Testing -- Chapter 30-Holter and Event Monitors -- Chapter 31-Electroencephalogram -- Chapter 32-Electromyography -- Chapter 33-Electronystagmography -- Part 5-Screening and Assessments for Specific Conditions and Diseases -- Chapter 34-Prenatal Tests -- Chapter 35-Infertility Tests -- Chapter 36-Vision Tests -- Section 36.1-Common Vision Tests -- Section 36.2-Comprehensive Dilated Eye Exam -- Section 36.3-Color Blindness Testing -- Chapter 37-Balance Tests -- Chapter 38-Eating Disorders: Suggested Medical Tests -- Chapter 39-Allergy Testing -- Section 39.1-Allergy Blood Test -- Section 39.2-Patch Tests for Allergies -- Chapter 40-Infectious Disease Testing -- Section 40.1-Chlamydia Test -- Section 40.2-Hepatitis Diagnostic Tests -- Section 40.3-Human Immunodeficiency Virus and Sexually Transmitted Disease Testing -- Section 40.4-Tuberculosis Test -- Chapter 41-Celiac Disease Tests -- Chapter 42-Diabetes Tests -- Section 42.1-Screening Tests for Diabetes -- Section 42.2-A1C Test -- Chapter 43-Thyroid Tests -- Chapter 44-Heart and Vascular Disease Screening and Diagnostic Tests -- Chapter 45-Bladder and Kidney Function Tests.</tableOfContents><tableOfContents>Section 45.1-Albumin Blood Test -- Section 45.2-Blood Urea Nitrogen Test -- Section 45.3-Calcium Blood Test -- Section 45.4-Calcium in Urine Test -- Section 45.5-Chloride Blood Test -- Section 45.6-Urodynamic Testing -- Section 45.7-Tracking Chronic Kidney Disease -- Chapter 46-Lung Disease Tests -- Section 46.1-Understanding Lung Function Tests -- Section 46.2-Cystic Fibrosis Tests -- Chapter 47-COVID-19 -- Section 47.1-About COVID-19 -- Section 47.2-Test for Current Infection -- Section 47.3-Test for Past Infection -- Section 47.4-Contact Tracing -- Section 47.5-Point of Care- and Rapid-Testing -- Chapter 48-Cancer Screening Tests -- Section 48.1-Cancer Screening Overview -- Section 48.2-Bladder and Other Urothelial Cancers -- Section 48.3-Breast Cancer -- Section 48.4-Cervical Cancer -- Section 48.5-Colorectal Cancer -- Section 48.6-Esophageal Cancer -- Section 48.7-Lung Cancer -- Section 48.8-Oral Cavity, Pharyngeal, and Laryngeal Cancer -- Section 48.9-Prostate Cancer -- Section 48.10-Skin Cancer -- Section 48.11-Testicular Cancer -- Section 48.12-Tumor Markers -- Chapter 49-Sleep Disorder Tests -- Chapter 50-Orthopedic/Musculoskeletal Examinations -- Chapter 51-Sports Assessments -- Part 6-Home and Self-Ordered Tests -- Chapter 52-An Introduction to Home-Use Medical Tests -- Chapter 53-Gynecological-Related Home Tests -- Section 53.1-Ovulation (Saliva Test) -- Section 53.2-Ovulation (Urine Test) -- Section 53.3-Home Pregnancy Test -- Section 53.4-Home Vaginal pH Test -- Section 53.5-Menopause Home Test -- Chapter 54-Cholesterol Home-Use Test -- Chapter 55-Diabetes Home Test -- Section 55.1-Monitoring Blood Sugar -- Section 55.2-Continuous Glucose Monitoring -- Chapter 56-HIV Home Test -- Chapter 57-Prothrombin Home Test -- Chapter 58-Drugs of Abuse Home Tests -- Chapter 59-Direct-to-Consumer Genetic Testing -- Chapter 60-COVID-19 Self-Testing.</tableOfContents><tableOfContents>Part 7-Additional Help and Information -- Chapter 61-Glossary of Terms Related to Medical Tests -- Chapter 62-Organizations with Resources for People Undergoing Medical Tests -- Index.</tableOfContents><relatedItem type="otherFormat" otherType="Print version:" displayLabel="Print version:"><titleInfo><title>Medical Tests Sourcebook, 7th Ed</title></titleInfo><name><namePart>Chambers, James</namePart></name><originInfo><publisher>Detroit : Infobase Holdings, Inc.,c2021</publisher></originInfo><identifier type="isbn">ISBN 9780780819788</identifier></relatedItem><identifier type="isbn">9780780819795</identifier><identifier type="isbn" invalid="yes">9780780819788</identifier><identifier type="oclc">1290484286</identifier><location><url displayLabel="electronic resource" usage="primary display" note="Click to View">https://ebookcentral.proquest.com/lib/huberlin-ebooks/detail.action?docID=6828456</url></location><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">MiAaPQ</recordContentSource><recordCreationDate encoding="marc">260630</recordCreationDate><recordChangeDate encoding="iso8601">20260630064852.0</recordChangeDate><recordIdentifier source="kobv">almahu_9950310897602882</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">eng</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>9</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><title>xUnit test patterns : refactoring test code</title></titleInfo><titleInfo type="abbreviated"><title>XUNIT TEST PATTERNS</title></titleInfo><titleInfo type="alternative"><title>XUNIT TEST PATTERNS</title></titleInfo><name type="personal" usage="primary"><displayForm>Meszaros, Gerard</displayForm><role><roleTerm type="text">Author</roleTerm></role></name><typeOfResource>text</typeOfResource><genre>text</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">xx</placeTerm></place><publisher>Pearson ITP</publisher><dateIssued keyDate="yes">2007</dateIssued><edition>1st edition</edition><issuance>monographic</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 online resource (944 pages)</extent><form type="media">computer</form><form type="carrier">online resource</form></physicalDescription><abstract type="Summary">Automated testing is a cornerstone of agile development. An effective testing strategy will deliver new functionality more aggressively, accelerate user feedback, and improve quality. However, for many developers, creating effective automated tests is a unique and unfamiliar challenge. xUnit Test Patterns is the definitive guide to writing automated tests using xUnit, the most popular unit testing framework in use today. Agile coach and test automation expert Gerard Meszaros describes 68 proven patterns for making tests easier to write, understand, and maintain. He then shows you how to make them more robust and repeatable--and far more cost-effective. Loaded with information, this book feels like three books in one. The first part is a detailed tutorial on test automation that covers everything from test strategy to in-depth test coding. The second part, a catalog of 18 frequently encountered "test smells," provides trouble-shooting guidelines to help you determine the root cause of problems and the most applicable patterns. The third part contains detailed descriptions of each pattern, including refactoring instructions illustrated by extensive code samples in multiple programming languages. Topics covered include Writing better tests--and writing them faster The four phases of automated tests: fixture setup, exercising the system under test, result verification, and fixture teardown Improving test coverage by isolating software from its environment using Test Stubs and Mock Objects Designing software for greater testability Using test "smells" (including code smells, behavior smells, and project smells) to spot problems and know when and how to eliminate them Refactoring tests for greater simplicity, robustness, and execution speed This book will benefit developers, managers, and testers working with any agile or conventional development process, whether doing test-driven development or writing the tests last. While the patterns and smells are especially applicable to all members of the xUnit family, they also apply to next-generation behavior-driven development frameworks such as RSpec and JBehave and to other kinds of test automation tools, including recorded test tools and data-driven test tools such as Fit and FitNesse. Visual Summary of the Pattern Language Foreword Preface Acknowledgments Introduction Refactoring a Test PART I: The Narratives Chapter 1 A Brief Tour Chapter 2 Test Smells Chapter 3 Goals of Test Automation Chapter 4 Phi...</abstract><tableOfContents>Intro -- Contents -- Visual Summary of the Pattern Language -- Foreword -- Preface -- Acknowledgments -- Introduction -- Refactoring a Test -- PART I. The Narratives -- Chapter 1. A Brief Tour -- About This Chapter -- The Simplest Test Automation Strategy That Could Possibly Work -- What's Next? -- Chapter 2. Test Smells -- About This Chapter -- An Introduction to Test Smells -- A Catalog of Smells -- What's Next? -- Chapter 3. Goals of Test Automation -- About This Chapter -- Why Test? -- Goals of Test Automation -- What's Next? -- Chapter 4. Philosophy of Test Automation -- About This Chapter -- Why Is Philosophy Important? -- Some Philosophical Differences -- When Philosophies Differ -- My Philosophy -- What's Next? -- Chapter 5. Principles of Test Automation -- About This Chapter -- The Principles -- What's Next? -- Chapter 6. Test Automation Strategy -- About This Chapter -- What's Strategic? -- Which Kinds of Tests Should We Automate? -- Which Tools Do We Use to Automate Which Tests? -- Which Test Fixture Strategy Do We Use? -- How Do We Ensure Testability? -- What's Next? -- Chapter 7. xUnit Basics -- About This Chapter -- An Introduction to xUnit -- Common Features -- The Bare Minimum -- Under the xUnit Covers -- xUnit in the Procedural World -- What's Next? -- Chapter 8. Transient Fixture Management -- About This Chapter -- Test Fixture Terminology -- Building Fresh Fixtures -- Tearing Down Transient Fresh Fixtures -- What's Next? -- Chapter 9. Persistent Fixture Management -- About This Chapter -- Managing Persistent Fresh Fixtures -- Managing Shared Fixtures -- What's Next? -- Chapter 10. Result Verification -- About This Chapter -- Making Tests Self-Checking -- State Verification -- Verifying Behavior -- Reducing Test Code Duplication -- Avoiding Conditional Test Logic -- Other Techniques -- Where to Put Reusable Verification Logic?.</tableOfContents><tableOfContents>What's Next? -- Chapter 11. Using Test Doubles -- About This Chapter -- What Are Indirect Inputs and Outputs? -- Testing with Doubles -- Other Uses of Test Doubles -- Other Considerations -- What's Next? -- Chapter 12. Organizing Our Tests -- About This Chapter -- Basic xUnit Mechanisms -- Right-Sizing Test Methods -- Test Methods and Testcase Classes -- Test Naming Conventions -- Organizing Test Suites -- Test Code Reuse -- Test File Organization -- What's Next? -- Chapter 13. Testing with Databases -- About This Chapter -- Testing with Databases -- Testing without Databases -- Testing the Database -- Testing with Databases (Again!) -- What's Next? -- Chapter 14. A Roadmap to Effective Test Automation -- About This Chapter -- Test Automation Difficulty -- Roadmap to Highly Maintainable Automated Tests -- What's Next? -- PART II. The Test Smells -- Chapter 15. Code Smells -- Obscure Test -- Conditional Test Logic -- Hard-to-Test Code -- Test Code Duplication -- Test Logic in Production -- Chapter 16. Behavior Smells -- Assertion Roulette -- Erratic Test -- Fragile Test -- Frequent Debugging -- Manual Intervention -- Slow Tests -- Chapter 17. Project Smells -- Buggy Tests -- Developers Not Writing Tests -- High Test Maintenance Cost -- Production Bugs -- PART III. The Patterns -- Chapter 18. Test Strategy Patterns -- Recorded Test -- Scripted Test -- Data-Driven Test -- Test Automation Framework -- Minimal Fixture -- Standard Fixture -- Fresh Fixture -- Shared Fixture -- Back Door Manipulation -- Layer Test -- Chapter 19. xUnit Basics Patterns -- Test Method -- Four-Phase Test -- Assertion Method -- Assertion Message -- Testcase Class -- Test Runner -- Testcase Object -- Test Suite Object -- Test Discovery -- Test Enumeration -- Test Selection -- Chapter 20. Fixture Setup Patterns -- In-line Setup -- Delegated Setup -- Creation Method.</tableOfContents><tableOfContents>Implicit Setup -- Prebuilt Fixture -- Lazy Setup -- Suite Fixture Setup -- Setup Decorator -- Chained Tests -- Chapter 21. Result Verification Patterns -- State Verification -- Behavior Verification -- Custom Assertion -- Delta Assertion -- Guard Assertion -- Unfinished Test Assertion -- Chapter 22. Fixture Teardown Patterns -- Garbage-Collected Teardown -- Automated Teardown -- In-line Teardown -- Implicit Teardown -- Chapter 23. Test Double Patterns -- Test Double -- Test Stub -- Test Spy -- Mock Object -- Fake Object -- Configurable Test Double -- Hard-Coded Test Double -- Test-Specific Subclass -- Chapter 24. Test Organization Patterns -- Named Test Suite -- Test Utility Method -- Parameterized Test -- Testcase Class per Class -- Testcase Class per Feature -- Testcase Class per Fixture -- Testcase Superclass -- Test Helper -- Chapter 25. Database Patterns -- Database Sandbox -- Stored Procedure Test -- Table Truncation Teardown -- Transaction Rollback Teardown -- Chapter 26. Design-for-Testability Patterns -- Dependency Injection -- Dependency Lookup -- Humble Object -- Test Hook -- Chapter 27. Value Patterns -- Literal Value -- Derived Value -- Generated Value -- Dummy Object -- PART IV. Appendixes -- Appendix A. Test Refactorings -- Appendix B. xUnit Terminology -- Appendix C. xUnit Family Members -- Appendix D. Tools -- Appendix E. Goals and Principles -- Appendix F. Smells, Aliases, and Causes -- Appendix G. Patterns, Aliases, and Variations -- Glossary.</tableOfContents><note>Bibliographic Level Mode of Issuance: Monograph</note><note type="bibliography">Includes bibliographical references and index.</note><note type="language">English</note><subject authority="lcsh"><topic>Software patterns</topic><topic>Testing.</topic></subject><subject authority="lcsh"><topic>Computer software.</topic></subject><subject authority="HILCC"><topic>Engineering &amp; Applied Sciences</topic></subject><subject authority="HILCC"><topic>Computer Science</topic></subject><classification authority="lcc">QA76.76.P37 M49 2007</classification><classification authority="ddc">005.1</classification><relatedItem type="series"><titleInfo><title>The Addison-Wesley signature series xUnit test patterns</title></titleInfo></relatedItem><relatedItem type="series"><titleInfo><title>Addison-Wesley signature series</title></titleInfo></relatedItem><relatedItem type="otherFormat"><identifier type="isbn">ISBN 9780131495050</identifier></relatedItem><relatedItem type="otherFormat"><identifier type="isbn">ISBN 0131495054</identifier></relatedItem><relatedItem type="series"><titleInfo><title>Addison-Wesley Signature Series (Fowler)</title></titleInfo></relatedItem><identifier type="isbn">9780321504807</identifier><identifier type="isbn">0321504801</identifier><identifier type="isbn">9780132797467</identifier><identifier type="isbn">0132797461</identifier><identifier type="oclc">154684541</identifier><identifier type="oclc">ocm154684541</identifier><identifier type="oclc">1531322903</identifier><identifier type="oclc">1337944947</identifier><recordInfo><recordContentSource authority="marcorg">PQKB</recordContentSource><recordCreationDate encoding="marc">160829</recordCreationDate><recordChangeDate encoding="iso8601">20261115165319.0</recordChangeDate><recordIdentifier source="kobv">almatuudk_9923192791802884</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record><srw:record>
    <srw:recordSchema>info:srw/schema/1/mods-v3.5</srw:recordSchema>
    <srw:recordPacking>xml</srw:recordPacking>
<srw:recordPosition>10</srw:recordPosition><srw:recordData><mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.loc.gov/mods/v3" version="3.6" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-6.xsd"><titleInfo><nonSort xml:space="preserve">A </nonSort><title>Practical Guide to Testing Wireless Smartphone Applications</title><subTitle>Julian Harty, Google Inc.</subTitle></titleInfo><name type="personal" usage="primary"><displayForm>Harty, Julian</displayForm><role><roleTerm type="text">VerfasserIn</roleTerm></role><role><roleTerm authority="marcrelator" type="code">aut</roleTerm></role></name><typeOfResource>text</typeOfResource><genre authority="rdacontent">Text</genre><genre authority="0">Electronic books</genre><genre authority="marcgt">book</genre><originInfo><place><placeTerm type="code" authority="marccountry">xxu</placeTerm></place><place><placeTerm type="code" authority="iso3166">XD-US</placeTerm></place><place><placeTerm type="text">[San Rafael]</placeTerm></place><publisher>Morgan &amp; Claypool Publishers</publisher><dateIssued>[2009]</dateIssued><dateIssued>© 2009</dateIssued><dateIssued encoding="w3cdtf" keyDate="yes">2009</dateIssued><issuance>single unit</issuance></originInfo><language><languageTerm authority="iso639-2b" type="code">eng</languageTerm></language><physicalDescription><form authority="marccategory">electronic resource</form><form authority="marcsmd">remote</form><extent>1 Online-Ressource (120 Seiten)</extent><form type="media" authority="rdamedia">Computermedien</form><form type="carrier" authority="rdacarrier">Online-Ressource</form></physicalDescription><abstract type="Summary">Testing applications for mobile phones is difficult, time-consuming and hard to do effectively. Many people have limited their testing efforts to hands-on testing of an application on a few physical handsets, and they have to repeat the process every time a new version of the software is ready to test. They may miss many of the permutations of real-world use, and as a consequence their users are left with the unpleasant mess of a failing application on their phone. Test automation can help to increase the range and scope of testing, while reducing the overhead of manual testing of each version of the software. However automation is not a panacea, particularly for mobile applications, so we need to pick our test automation challenges wisely. This book is intended to help software and test engineers pick appropriately to achieve more; and as a consequence deliver better quality, working software to users</abstract><abstract type="Summary">Preface -- What is inside -- Conventions -- What you will need -- Using code examples -- Alphabet soup and the half-life of links -- Acknowledgments -- 1. Introduction -- What is a mobile wireless application -- Classifications of mobile wireless applications -- Client applications -- Messaging applications -- Browser applications -- The supporting servers -- Things that do not quite fit -- Currently outside the scope of this book -- Scope of mobile wireless test automation -- Challenges in testing mobile wireless applications -- Problem space -- Transcoding web content -- Our testing focus -- Our goals when testing -- Our overall testing strategy -- Core concepts -- 2. Markup languages -- Examples of markup languages -- Testing strategy for markup applications -- Example problems -- 3. Testing techniques for markup applications -- Getting started with test automation -- Examples written in Python -- A test to detect if Google maps is offered to mobile users -- Using regular expressions in our test -- Combining XML with regular expressions -- Using XPATH in our tests -- Summary of the examples in Python -- Building on your first automated scripts -- Data-driven tests -- Obtaining metadata to drive our tests -- Using metadata -- Test using carrier networks -- Timing the request/response pair -- Implementing rule-based tests -- Probe servers -- Strengths and weaknesses of rule-based testing -- A complementary tool to rule-based tests -- Is appropriate content being served -- Tips when implementing automated test scripts -- Test tools for browser-based applications -- Using web-testing tools -- Mobile readiness tools -- Utilities to help with testing browser applications</abstract><abstract type="Summary">8. Common techniques -- GUI-level automation -- Image stitching -- Steps in image stitching -- Challenges of image matching -- Optical character recognition -- Encoding data in pixels -- Making image matching easier -- Using advanced image matching techniques -- Detecting good and bad results -- Contact sheets -- Using transparency masking -- Combining automation with human judgment -- Model based testing -- 9. When to test manually -- Examples of effective manual testing -- Computer-assisted testing for mobile wireless applications -- Testability for automated testing -- How to improve testability -- Browser-based applications -- Client applications -- SMS applications -- General -- 10. Future work -- Appendix A. Links and references -- A.1. Testing markup (web sites) -- A.2. J2ME testing -- A.3. Java byte code instrumentation -- A.4. Native application testing -- A.5. Test automation with emulators -- A.6. SMS services -- A.7. Connectivity -- A.8. Miscellaneous links -- A.9. Common tools -- A.10. Other references -- A.11. Raw ingredients -- Appendix B. Data connectivity -- B.1. How to use a mobile phone modem interactively -- B.2. How to use a mobile phone modem for IP traffic -- B.3. Possible problems with data connectivity -- B.4. Miscellaneous problems -- Appendix C. Configuring your machine -- C.1. Raw ingredients -- C.2. Prepare the device -- C.3. Connecting your modem or phone -- C.4. Using Hyperterminal in Windows -- C.5. Using Minicom in Linux -- C.6. Configuring PPP in Windows -- C.7. Configuring PPP in Linux -- Author biography</abstract><abstract type="Summary">4. AJAX mobile applications -- Testing challenges for AJAX mobile applications -- Examples of problems with mobile AJAX applications -- 5. Testing mobile AJAX applications -- Using desktop browser automation tools -- Selenium -- Webdriver -- Customizing desktop web browsers -- Limitations of using desktop web browsers -- Using an embedded browser -- Using simulators -- General tips -- Selenium tips for mobile AJAX automation -- WebDriver tips for mobile AJAX automation -- 6. Client applications -- Portable applications -- Native applications -- Developing native applications -- Example problems for portable applications -- Example problems for native applications -- 7. Testing strategy for client applications -- Testing techniques for client applications -- Automated unit tests -- Examples of unit tests -- Running unit tests in an emulator -- System testing for iPhone applications -- Code injection -- Code injection for Java ME -- Custom test applications -- Prober clients -- Signature testing -- Test tools for client applications -- On-device debugging -- Test automation of the runtime environment -- Emulators -- Test automation using the Blackberry emulator -- Summary of testing techniques for client applications</abstract><tableOfContents>A Practical Guide to Testing Wireless Smartphone Applications; Synthesis Lectures on Mobile and Pervasive Computing; Abstract; Keywords; Preface; What Is Inside; Conventions; What You Will Need; Using Code Examples; Alphabet Soup and the Half-life of Links; Acknowledgments; Contents; chapter 1 Introduction; 1.1 WHAT IS A MOBILE WIRELESS APPLICATION?; 1.2 CLASSIFICATIONS OF MOBILE WIRELESS APPLICATIONS; 1.2.1 Client Applications; 1.2.2 Messaging Applications; 1.2.3 Browser Applications; 1.2.4 The Supporting Servers; 1.2.5 Things That Do Not Quite Fit</tableOfContents><tableOfContents>1.3 CURRENTLY OUTSIDE THE SCOPE OF THIS BOOK1.4 SCOPE OF MOBILE WIRELESS TEST AUTOMATION; 1.5 CHALLENGES IN TESTING MOBILE WIRELESS APPLICATIONS; 1.6 PROBLEM SPACE; 1.6.1 Transcoding Web Content; 1.7 OUR TESTING FOCUS; 1.8 OUR GOALS WHEN TESTING; 1.9 OUR OVERALL TESTING STRATEGY; 1.10 CORE CONCEPTS; chapter 2 Markup Languages; 2.1 EXAMPLES OF MARKUP LANGUAGES; 2.2 TESTING STRATEGY FOR MARKUP APPLICATIONS; 2.3 EXAMPLE PROBLEMS; chapter 3 Testing Techniques for Markup Applications; 3.1 GETTING STARTED WITH TEST AUTOMATION; 3.2 EXAMPLES WRITTEN IN PYTHON</tableOfContents><tableOfContents>3.2.1 A Test to Detect if Google Maps Is Offered to Mobile Users3.2.2 Using Regular Expressions in Our Test; 3.2.3 Combining XML With Regular Expressions; 3.2.4 Using XPATH in Our Tests; 3.3 SUMMARY OF THE EXAMPLES IN PYTHON; 3.4 BUILDING ON YOUR FIRST AUTOMATED SCRIPTS; 3.4.1 Data-Driven Tests; 3.4.2 Obtaining Metadata to Drive Our Tests; 3.4.3 Using Metadata; 3.4.4 Test Using Carrier Networks; 3.4.5 Timing the Request/Response Pair; 3.4.6 Implementing Rule-Based Tests; 3.4.7 Probe Servers; 3.4.8 Strengths and Weaknesses of Rule-Based Testing; 3.4.9 A Complementary Tool to Rule-Based Tests</tableOfContents><tableOfContents>3.4.10 Is Appropriate Content Being Served?3.5 TIPS WHEN IMPLEMENTING AUTOMATED TEST SCRIPTS; 3.6 TEST TOOLS FOR BROWSER-BASED APPLICATIONS; 3.6.1 Using Web-Testing Tools; 3.6.3 Utilities to Help With Testing Browser Applications; chapter 4 AJAX Mobile Applications; 4.1 TESTING CHALLENGES FOR AJAX MOBILE  APPLICATIONS; 4.2 EXAMPLES OF PROBLEMS WITH MOBILE AJAX  APPLICATIONS; chapter 5 Testing Mobile AJAX Applications; 5.1 USING DESKTOP BROWSER AUTOMATION TOOLS; 5.1.1 Selenium; 5.1.2 WebDriver; 5.1.3 Customizing Desktop Web Browsers; 5.1.4 Limitations of Using Desktop Web Browsers</tableOfContents><tableOfContents>5.2 USING AN EMBEDDED BROWSER5.3 Using Simulators; 5.4 General Tips; 5.4.1 Selenium Tips for Mobile AJAX Automation; 5.4.2 WebDriver Tips for Mobile AJAX Automation; chapter 6 Client Applications; 6.1 PORTABLE APPLICATIONS; 6.2 NATIVE APPLICATIONS; 6.2.1 Developing Native Applications; 6.2.2 Example Problems for Portable Applications; 6.2.3 Example Problems for Native Applications; 6.3 TESTING STRATEGY FOR CLIENT APPLICATIONS; chapter 7 Testing Techniques for Client Applications; 7.1 AUTOMATED UNIT TESTS; 7.1.1 Examples of  Unit Tests; 7.1.2 Running Unit Tests in an Emulator</tableOfContents><tableOfContents>7.2 SYSTEM TESTING FOR iPHONE APPLICATIONS</tableOfContents><tableOfContents>4. AJAX mobile applications -- Testing challenges for AJAX mobile applications -- Examples of problems with mobile AJAX applications -- 5. Testing mobile AJAX applications -- Using desktop browser automation tools -- Selenium -- Webdriver -- Customizing desktop web browsers -- Limitations of using desktop web browsers -- Using an embedded browser -- Using simulators -- General tips -- Selenium tips for mobile AJAX automation -- WebDriver tips for mobile AJAX automation -- 6. Client applications -- Portable applications -- Native applications -- Developing native applications -- Example problems for portable applications -- Example problems for native applications -- 7. Testing strategy for client applications -- Testing techniques for client applications -- Automated unit tests -- Examples of unit tests -- Running unit tests in an emulator -- System testing for iPhone applications -- Code injection -- Code injection for Java ME -- Custom test applications -- Prober clients -- Signature testing -- Test tools for client applications -- On-device debugging -- Test automation of the runtime environment -- Emulators -- Test automation using the Blackberry emulator -- Summary of testing techniques for client applications.</tableOfContents><tableOfContents>8. Common techniques -- GUI-level automation -- Image stitching -- Steps in image stitching -- Challenges of image matching -- Optical character recognition -- Encoding data in pixels -- Making image matching easier -- Using advanced image matching techniques -- Detecting good and bad results -- Contact sheets -- Using transparency masking -- Combining automation with human judgment -- Model based testing -- 9. When to test manually -- Examples of effective manual testing -- Computer-assisted testing for mobile wireless applications -- Testability for automated testing -- How to improve testability -- Browser-based applications -- Client applications -- SMS applications -- General -- 10. Future work -- Appendix A. Links and references -- A.1. Testing markup (web sites) -- A.2. J2ME testing -- A.3. Java byte code instrumentation -- A.4. Native application testing -- A.5. Test automation with emulators -- A.6. SMS services -- A.7. Connectivity -- A.8. Miscellaneous links -- A.9. Common tools -- A.10. Other references -- A.11. Raw ingredients -- Appendix B. Data connectivity -- B.1. How to use a mobile phone modem interactively -- B.2. How to use a mobile phone modem for IP traffic -- B.3. Possible problems with data connectivity -- B.4. Miscellaneous problems -- Appendix C. Configuring your machine -- C.1. Raw ingredients -- C.2. Prepare the device -- C.3. Connecting your modem or phone -- C.4. Using Hyperterminal in Windows -- C.5. Using Minicom in Linux -- C.6. Configuring PPP in Windows -- C.7. Configuring PPP in Linux -- Author biography.</tableOfContents><tableOfContents>Preface -- What is inside -- Conventions -- What you will need -- Using code examples -- Alphabet soup and the half-life of links -- Acknowledgments -- 1. Introduction -- What is a mobile wireless application -- Classifications of mobile wireless applications -- Client applications -- Messaging applications -- Browser applications -- The supporting servers -- Things that do not quite fit -- Currently outside the scope of this book -- Scope of mobile wireless test automation -- Challenges in testing mobile wireless applications -- Problem space -- Transcoding web content -- Our testing focus -- Our goals when testing -- Our overall testing strategy -- Core concepts -- 2. Markup languages -- Examples of markup languages -- Testing strategy for markup applications -- Example problems -- 3. Testing techniques for markup applications -- Getting started with test automation -- Examples written in Python -- A test to detect if Google maps is offered to mobile users -- Using regular expressions in our test -- Combining XML with regular expressions -- Using XPATH in our tests -- Summary of the examples in Python -- Building on your first automated scripts -- Data-driven tests -- Obtaining metadata to drive our tests -- Using metadata -- Test using carrier networks -- Timing the request/response pair -- Implementing rule-based tests -- Probe servers -- Strengths and weaknesses of rule-based testing -- A complementary tool to rule-based tests -- Is appropriate content being served -- Tips when implementing automated test scripts -- Test tools for browser-based applications -- Using web-testing tools -- Mobile readiness tools -- Utilities to help with testing browser applications.</tableOfContents><note>Description based upon print version of record</note><note type="additional physical form">Also available in print.</note><note type="reproduction">Reproduktion Also available in print</note><note type="system details">System requirements: Adobe Acrobat reader.</note><note type="system details">Mode of access: World Wide Web.</note><subject authority="lcsh"><topic>Mobile computing</topic><topic>Testing</topic></subject><subject authority="lcsh"><topic>Wireless communication systems</topic><topic>Computer programs</topic><topic>Testing</topic></subject><subject authority="lcsh"><topic>Cellular telephones</topic><topic>Computer programs</topic><topic>Testing</topic></subject><classification authority="lcc">TK5103.2 .H259 2009</classification><classification authority="lcc">TK6570.M6</classification><classification authority="ddc">621.38</classification><classification authority="ddc">621.38456</classification><relatedItem type="otherFormat"><identifier type="isbn">ISBN 9781608452538</identifier></relatedItem><relatedItem type="otherFormat" otherType="Erscheint auch als" displayLabel="Erscheint auch als"><name><namePart>A Practical Guide to Testing Wireless Smartphone Applications</namePart></name><note>Druck-Ausgabe</note></relatedItem><relatedItem type="series"><titleInfo><title>Synthesis lectures on mobile and pervasive computing</title></titleInfo><part><detail><number>#6</number></detail></part><recordInfo><recordIdentifier>(DE-627)894815296</recordIdentifier></recordInfo></relatedItem><identifier type="isbn">9781608452545</identifier><identifier type="doi">10.2200/S00219ED1V01Y200909MPC006</identifier><identifier type="oclc">1255405816</identifier><location><url displayLabel="Abstract with links to full text Volltext" usage="primary display">http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=6813230</url></location><location><url displayLabel="Abstract with links to full text Volltext">http://ieeexplore.ieee.org/servlet/opac?bknumber=6813230</url></location><accessCondition type="restriction on access">Abstract freely available; full-text restricted to subscribers or individual document purchasers</accessCondition><recordInfo><descriptionStandard>rda</descriptionStandard><recordContentSource authority="marcorg">DE-627</recordContentSource><recordCreationDate encoding="marc">120831</recordCreationDate><recordChangeDate encoding="iso8601">20251224181546.0</recordChangeDate><recordIdentifier source="kobv">gbv_723615969</recordIdentifier><recordOrigin>Converted from MARCXML to MODS version 3.6 using MARC21slim2MODS3-6.xsl
				(Revision 1.119 2018/06/21)</recordOrigin><languageOfCataloging><languageTerm authority="iso639-2b" type="code">ger</languageTerm></languageOfCataloging></recordInfo><extension><vlz:info xmlns:vlz="http://visuallibrary.net/vlz/1.0/" version="0"/></extension></mods></srw:recordData></srw:record></srw:records>
</srw:searchRetrieveResponse>