Test
A test is a procedure or check that evaluates behavior using specified inputs or evidence against expected results or criteria.
Learn AI-Assisted Python Programming, Second Edition
A test case is a defined software-testing scenario consisting of inputs and the expected behavior or result.
- How it is used
- Uses defined inputs and expected results to check functions, expose incorrect behavior, and increase confidence in code.
- How deep it goes
- Explains common and edge-case selection, regression testing, artificial files, and doctest execution without formal coverage methods.
- Examples
- Demonstrates longest-word lists, classroom rows, NFL passing-yard files, boundary comparisons, and consecutive-student counts.
- What you can do after
- Diagnose incorrect behavior, revise code or prompts, and verify common and edge cases with Python doctests or interactive calls.
Read how Learn AI-Assisted Python Programming, Second Edition explains test →
Software Testing with Generative AI
A test case is a defined set of inputs, conditions, and expected outcomes for evaluating a particular software behavior.
- How it is used
- Uses defined behaviors, conditions, and outcomes to organize manual or automated evaluation within risk-based test planning.
- How deep it goes
- Explains inputs, conditions, expected outcomes, risk alignment, and repetition checks, but stops short of prescribing a complete testing strategy.
- Examples
- Demonstrates file-upload validation and booking-list behavior under different speeds and user loads.
- What you can do after
- Apply it via risk-based planning to define focused checks and evaluate generated cases before using them.
Read how Software Testing with Generative AI explains test →
Learn Go with Pocket-Sized Projects
A test case is a defined test scenario containing inputs and the expected result of execution.
- How it is used
- Checks expected behavior repeatedly as code changes, including successful inputs, unsupported inputs, and service responses.
- How deep it goes
- Works through assertions, named scenarios, table-driven tests, stubs, and unit-test boundaries; also cautions against implementation-bound or order-dependent checks.
- Examples
- Uses greeting languages, maze image fixtures, habit validation, and an HTTP handler to demonstrate different inputs and assertions.
- What you can do after
- Practice/perform Go tests by defining scenarios, running named subtests, checking results, and choosing assertions that match each case.
Read how Learn Go with Pocket-Sized Projects explains test →
Shipping Go: Develop, deliver, discuss, design, and go again
A test case is a defined set of inputs, conditions, and expected results for evaluating software behavior.
- How it is used
- Uses test cases to validate business behavior early, reduce repeated bugs, and gate changes before a build.
- How deep it goes
- Works through selecting boundaries, writing translation cases, running tests, and checking coverage; defers full-system end-to-end UI-to-API testing.
- Examples
- Uses a Go translation service with expected outputs, unsupported inputs, capitalization, whitespace, and a CI test job.
- What you can do after
- Practice/perform writing behavior-focused cases and running them as an automated quality gate before building.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains test →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
A documented sequence of actions and conditions that demonstrates or evaluates a specified software behavior.
- How it is used
- Checks microservice behavior repeatedly as applications grow and code changes move toward deployment.
- How deep it goes
- Builds from a named Jest assertion to mocked microservice tests and outlines integration and end-to-end scope without pursuing complete coverage.
- Examples
- Uses a square-function assertion, mocked /videos route tests, and frontend tests against an application started with Docker Compose.
- What you can do after
- Apply it via Jest and Playwright to check code at several scopes and gate deployment through CI/CD.
Data-Oriented Programming: Reduce software complexity
A test case is a specific set of input data, execution conditions, and expected results used to evaluate software behavior.
- How it is used
- Structures unit tests for data-manipulating functions by comparing returned data with expected data.
- How deep it goes
- Defines a three-step pattern and calibrates case quantity by function-call depth, while deferring test runners and frameworks.
- Examples
- Uses catalog author-name queries, empty and missing data, nonexistent authors, and book-information records.
- What you can do after
- Build test cases from scratch for data-oriented queries and mutations using generated inputs, expected outputs, and recursive comparison.
Read how Data-Oriented Programming: Reduce software complexity explains test →
ASP.NET Core in Action, 3e
A test is an automated program method that evaluates whether application behavior matches an expected result.
- How it is used
- Verifies service behavior in isolation and checks how ASP.NET Core components work together.
- How deep it goes
- Works through assertions, input selection, middleware, controllers, and database isolation, but defers broader debates about test timing and coverage.
- Examples
- Uses currency conversion, a health-check middleware, an API controller, and a recipe service backed by an in-memory database.
- What you can do after
- Apply it via xUnit and `dotnet test` to check expected results, failures, and isolated ASP.NET Core behavior.
Build Python Web Apps with Streamlit
A test function is a callable test definition that exercises software and compares observed results with expected results.
- How it is used
- Checks whether app behavior matches expectations, helping catch regressions and unexpected results.
- How deep it goes
- Works through setup, mocked dependencies, calls, assertions, failures, and UI interaction; does not claim the resulting suite is comprehensive.
- Examples
- Uses arithmetic assertions, mocked movie searches, simulated UI clicks, and a missing rating to demonstrate passing and failing tests.
- What you can do after
- Apply it via pytest and Streamlit AppTest to check backend results and simulated frontend behavior.
Read how Build Python Web Apps with Streamlit explains test →
Coding with AI
A test case is a defined input, execution condition, and expected result used to evaluate software behavior.
- How it is used
- Uses AI assistance during testing to generate cases, broaden coverage, and identify places where software might fail.
- How deep it goes
- Explains generated-test workflows and benefits but stops short of specifying test-design theory or a complete implementation.
- Examples
- Demonstrates GitHub Copilot, Tabnine, Blackbox, ChatGPT, Bing, and Gemini generating tests or debugging suggestions.
- What you can do after
- Apply via AI coding tools to generate unit tests faster, uncover overlooked cases, and investigate failures.
Authorization in Action
A test is an executable check that evaluates software behavior against expected outcomes.
- How it is used
- Verifies that authorization policies enforce intended allow and deny decisions before deployment.
- How deep it goes
- Develops unit, scenario, regression, and coverage tests, then extends testing to layered-policy interactions and staged rollouts.
- Examples
- Uses project-member document viewing, unmanaged devices, manager inheritance, delegation, and cross-layer device-posture scenarios.
- What you can do after
- Apply it via Cedar policy tests and CI checks to validate decisions, prevent regressions, and detect interaction failures.
Get Programming: Learn to code with Python
A defined set of inputs and expected results used to evaluate whether software behaves correctly.
- How it is used
- Checks program behavior against planned results throughout the think-code-test-debug-repeat cycle.
- How deep it goes
- Develops hand-written input-output cases, intermediate checks, and separate-file unit tests using Arrange, Act, Assert.
- Examples
- Uses minute conversions, varied name inputs, and failing prime and absolute-value checks.
- What you can do after
- Apply it via Python’s unittest library to compare actual and expected function results and locate failed cases.
Read how Get Programming: Learn to code with Python explains test →
Build AI-Enhanced Web Apps
Testing is the systematic evaluation of software behavior to detect defects and verify that it meets its intended requirements.
- How it is used
- Verifies component behavior and AI workflows while reducing unexpected failures in web applications.
- How deep it goes
- Distinguishes unit and integration scope, gives runnable checks and mocking examples, but defers detailed unit-test infrastructure setup.
- Examples
- Uses chat-component assertions, semantic-similarity and constraint checks, and fake language-model and retriever responses.
- What you can do after
- Practice/perform unit and integration checks with controlled AI responses, including error and edge-case checks.
Go by Example
A test case is a defined test scenario consisting of inputs, execution conditions, and expected behavior or results.
- How it is used
- Uses automated tests to preserve behavior through change while improving code testability and maintainability.
- How deep it goes
- Builds runnable Go tests through conventions, assertions, table cases, subtest failure isolation, and unit or handler testing.
- Examples
- Demonstrates URL parsing and formatting, CLI flag parsing, and an HTTP health handler with ResponseRecorder.
- What you can do after
- Apply it via Go’s testing package and go test to write, run, organize, and diagnose automated tests.
Lead Developer Career Guide
A specified set of inputs, conditions, and expected results for evaluating software behavior.
- How it is used
- Uses test cases within QA to check software behavior and support consistent quality across projects.
- How deep it goes
- Outlines QA stages and compares testing approaches, but does not give a worked test case or implementation steps.
- Examples
- Illustrates automated testing through a fragile deployment pipeline improved by adding a testing framework and more tests.
- What you can do after
- Practice/perform test planning by combining testing approaches and reviewing recurring failures to guide coverage.
React in Depth
Software testing is the category of practices and tools for evaluating software behavior and correctness.
- How it is used
- Automates checks of React component behavior to reduce missed interactions and regressions after changes.
- How deep it goes
- Works through static-component assertions and interactive form testing, while leaving invalid-input and zero-time behavior outside the form example.
- Examples
- Uses a navigation link’s attributes and text plus a timer form’s number inputs, submit button, and callback.
- What you can do after
- Apply it via Vitest and React Testing Library to test static and interactive components and mock troublesome dependencies.
Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
A test case is an individual set of checks, inputs, and expected outcomes for evaluating software or infrastructure behavior.
- How it is used
- Checks expected infrastructure behavior after deployment, with multiple cases sharing a configuration when possible.
- How deep it goes
- Walks through configuration, deployment, checks, and teardown, then distinguishes isolated, integrated, and provider acceptance tests.
- Examples
- Uses web-service endpoints and redirects, contrasting S3 configurations, and a pytest assertion that initialization creates .terraform.
- What you can do after
- Practice/perform grouped infrastructure checks, separate conflicting configurations, and clean up deployed test resources.
Read how Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu explains test →
Code Like a Pro in Rust
A test case is a specific input and execution scenario used to check software behavior or reproduce a failure.
- How it is used
- Checks required behavior and catches regressions using specific inputs, including cases that expose failures the compiler cannot rule out.
- How deep it goes
- Works through unit and integration test boundaries, assertions, generated failing inputs, and fuzzing; does not prescribe an exhaustive set of cases.
- Examples
- Uses quicksort assertions, an overflow-inducing generated input, and a fuzzed string parser to illustrate checked behavior and failures.
- What you can do after
- Practice/perform test-case selection across public and private boundaries, and use generated failures to investigate missed edge cases.
100 Java Mistakes and How to Avoid Them
A test case is a defined set of inputs, execution conditions, and expected results for evaluating software behavior.
- How it is used
- Uses automated and unit tests to detect behavior defects and notify developers of regressions.
- How deep it goes
- Explains practical test design, execution traps, property testing, and coverage limits without teaching a complete testing methodology.
- Examples
- Demonstrates a prematurely returning exception test, branch and loop cases, string processing, oddness checks, and UI messages.
- What you can do after
- Apply it via JUnit-style assertions and automated-test strategies to catch regressions and reveal common Java mistakes.
Read how 100 Java Mistakes and How to Avoid Them explains test →
Learn Rust in a Month of Lunches
A test function is a Rust function executed by the test framework to check program behavior and normally takes no arguments.
- How it is used
- Checks program behavior beyond what compilation catches and flags problems after code changes.
- How deep it goes
- Works through assertions, failure output, test modules, and test-first iterations; defers fuller treatment of environment variables.
- Examples
- Uses a two-value assertion, tests of small arithmetic functions, and a subtraction calculator with invalid-input cases.
- What you can do after
- Apply it via `cargo test` or the Playground’s Test button to run tests and use failures to guide fixes.
Refactoring to Rust
A test function is a Rust function registered as an automated test by the test framework.
- How it is used
- Checks that small Rust refactors preserve expected behavior and that new functions return expected results.
- How deep it goes
- Works through test-module scaffolding, conditional compilation, assertions, test runs, failures, output options, and additional cases.
- Examples
- Uses Cargo’s arithmetic test, a deliberately failing assertion, and JSON inputs checked against expected sums.
- What you can do after
- Build it from scratch with `#[test]` and `assert_eq!`, then run and inspect the tests with `cargo test`.
Quantum Programming in Depth
A test case is a specified input scenario and expected result used to evaluate software behavior.
- How it is used
- Uses automated simulator runs to validate quantum-library operations and state-preparation behavior.
- How deep it goes
- Derives test selection from state properties and corner cases, then implements repeated simulations, decoding, assertions, and coefficient checks.
- Examples
- Uses distinct-amplitude states, negative or zero amplitudes, basis states, randomized basis-state readouts, and reconstructed coefficient estimates.
- What you can do after
- Diagnose/debug quantum code by selecting revealing inputs, running simulator shots, decoding results, and asserting expected states or coefficients.
F# in Action: A Revised Edition of Get Programming with F#
Test is Expecto's compositional test value, representing either an individual test or a collection of nested tests.
- How it is used
- Builds repeatable checks of F# production behavior, especially when changing risky or complex code.
- How deep it goes
- Works through AAA function tests and Expecto composition, while deferring comprehensive unit-testing practice.
- Examples
- Uses instrument sounds, validated email, nested suites, and addition cases read from a text file.
- What you can do after
- Apply it via Expecto to compose, run, conditionally select, and data-generate named F# tests.
Read how F# in Action: A Revised Edition of Get Programming with F# explains test →
Think Like a Software Engineering Manager
Software testing is the systematic evaluation of software to detect defects and verify that it meets specified behavioral and quality requirements.
- How it is used
- Supports implementation and release preparation by checking behavior and feeding defects into triage.
- How deep it goes
- Defines common test types, coverage measures, and management trade-offs without detailing test code or tools.
- Examples
- Uses methods, interacting modules, whole-application behavior, and simulated customer traffic to distinguish test types.
- What you can do after
- Practice/perform it by requiring unit tests, monitoring coverage, and coordinating testing with defect triage.
Read how Think Like a Software Engineering Manager explains test →
Kafka Streams in Action, Second Edition
Testing is the systematic evaluation of software behavior against expected results under defined inputs and conditions.
- How it is used
- Validates Kafka client and Streams behavior while preserving fast feedback during development, refactoring, and continuous integration.
- How deep it goes
- Walks through mock-based client testing and full-topology testing, while deferring broader integration-test implementation details.
- Examples
- Uses a currency-exchange client and a Yelling Kafka Streams topology that uppercases piped input records.
- What you can do after
- Apply it via MockConsumer, MockProducer, TopologyTestDriver, and Testcontainers to validate Kafka applications with or without a live broker.
Read how Kafka Streams in Action, Second Edition explains test →
Python How-To
A test case is a defined set of inputs, execution conditions, and expected results for evaluating software behavior.
- How it is used
- Checks a specific input against an expected result so application behavior can be checked again after code changes.
- How deep it goes
- Works through TestCase methods, assertions, passing output, and a failure; keeps the treatment introductory.
- Examples
- Uses task creation from strings and dictionaries, then a formatted-display assertion with a missing space.
- What you can do after
- Build it from scratch with unittest.TestCase and assertEqual, then inspect reported differences when an assertion fails.
Functional Design and Architecture: Examples in Haskell
A test case is a defined test scenario with inputs, actions, and expected results for evaluating specific behavior.
- How it is used
- Uses tests to validate requirements, fixate contracts, prevent regressions, and reduce architectural project risk.
- How deep it goes
- Explains test purposes, testing levels, AAA structure, independence, mocks, and architecture-driven testability without prescribing a complete methodology.
- Examples
- Demonstrates hspec cases for a square function, an IORef-dependent action, and device-component assembly using fake vendor APIs.
- What you can do after
- Apply it via hspec to structure independent AAA test cases and select testing approaches for different risks.
Read how Functional Design and Architecture: Examples in Haskell explains test →
Rust Servers, Services, and Apps
Testing is the systematic evaluation of software behavior against expected results under specified scenarios.
- How it is used
- Detects regressions as Rust web APIs evolve and supports live checks of server endpoints.
- How deep it goes
- Demonstrates async handler tests with constructed inputs and state, then status assertions; notes that real-world coverage should be broader.
- Examples
- Tests course creation and retrieval, and checks static pages, JSON responses, health, and invalid paths.
- What you can do after
- Apply it via Rust test utilities and Actix’s async test annotation to invoke handlers, assert responses, and check APIs with curl.
Grokking Machine Learning
The evaluation of a trained model on data used to assess its predictive performance.
- How it is used
- Uses held-out testing to check whether models generalize and to compare performance when selecting model complexity.
- How deep it goes
- Explains a held-out split, generalization, and training-versus-testing errors through model comparisons.
- Examples
- Illustrates an 80/20 exam-question split and compares degree-1, degree-2, and degree-10 models using mean absolute error.
- What you can do after
- Evaluate model generalization by holding out data and comparing training and testing errors.
Delivering Machine Learning Projects: From design to deployment
Testing is the systematic checking of software, models, or processes against specified conditions to reveal defects or assess suitability.
- How it is used
- Guides reproducible model evaluation and evidence-based selection before production and application integration.
- How deep it goes
- Specifies environments, offline or online practices, documentation, reproduction, and retesting, but does not detail individual test algorithms.
- Examples
- Uses a Sprint 2 checklist, model repositories, experiment results, test environments, documented defects, and integration-triggered reruns.
- What you can do after
- Evaluate models reproducibly, select candidates with defensible evidence, and diagnose when integration or drift requires retesting.
Read how Delivering Machine Learning Projects: From design to deployment explains test →
Web Components in Action
Software testing is the systematic execution and evaluation of software to detect defects and verify expected behavior.
- How it is used
- Builds confidence in component behavior and maintainability by checking functionality and edge cases.
- How deep it goes
- Defines unit and functional testing, then works through component assertions and coverage; distinguishes browser testing from unsupported JSDOM use.
- Examples
- Uses RGB-to-hex edge cases and slider value, attribute, and thumbnail-position assertions.
- What you can do after
- Apply testing with WCT, Mocha, and Chai to check component APIs, reflected attributes, visual state, and edge cases.
Data Pipelines with Apache Airflow, Second Edition
A test function is a callable function whose execution verifies expected software behavior.
- How it is used
- Checks Airflow DAGs and operators before deployment and helps investigate failures during development.
- How deep it goes
- Distinguishes unit and integration tests, demonstrates operator execution and mocking, and leaves acceptance testing outside scope.
- Examples
- Uses pytest functions that execute operators, assert results, and replace a metastore connection lookup with a mock.
- What you can do after
- Apply it via pytest to test operators, mock connection calls, and run checks in CI/CD.
Read how Data Pipelines with Apache Airflow, Second Edition explains test →
Spring in Action, Sixth Edition
An automated test is executable code that checks software behavior without requiring a human to perform each test step.
- How it is used
- Establishes an automated startup check while a Spring application grows.
- How deep it goes
- Defines executable tests and demonstrates one context-loading test, but does not develop behavioral test cases.
- Examples
- Uses TacoCloudApplicationTests and its empty contextLoads() method as the baseline example.
- What you can do after
- Diagnose startup failures by running a Spring context-loading test through Maven.
Machine Learning Platform Engineering
A testing loop is an iterative procedure that evaluates a model on test inputs during or between training steps.
- How it is used
- Deploys testing across CI, model training, optimized inference, and staging gates to catch defects before production.
- How deep it goes
- Explains testing cadence, CI stages, deployment gates, and environment differences, but stops short of detailed test design or metrics.
- Examples
- Uses pytest in GitLab CI, a PyTorch recommender testing loop, optimized embedded inference, and staging-versus-production evaluation.
- What you can do after
- Apply testing via pytest, GitLab CI, PyTorch dataloaders, and staging evaluation before building or promoting deployments.
Read how Machine Learning Platform Engineering explains test →
The Art of Code
A test is an executable evaluation that checks software behavior against expected outcomes.
- How it is used
- Uses verification to expose defects, protect software durability, and guide risk decisions before changes reach users.
- How deep it goes
- Defines testing's rationale and categories, then demonstrates unit-test cases; it does not detail comprehensive test planning.
- Examples
- Uses a WeightConverter with valid, zero, and negative-input unit tests, alongside a taxonomy of test types and tools.
- What you can do after
- Apply it via JUnit unit tests to verify normal results, boundary values, and expected exceptions.
The Art of AI Product Development
Testing is the systematic examination of a product, feature, or model to assess its behavior and quality.
- How it is used
- Evaluates AI design concepts and deployed model behavior against user expectations, product quality, and business outcomes.
- How deep it goes
- Moves from prototype error simulation to production feedback and metrics, but does not prescribe a complete testing protocol.
- Examples
- Simulates hallucinated emissions figures, regulatory misinterpretations, uncertain estimates, and misaligned tables; gathers live feedback with rating widgets.
- What you can do after
- Evaluate/understand user responses to simulated AI uncertainty and production outputs, then use findings to adjust designs and improve the product.
Prompt Engineering in Practice
The systematic evaluation of a component against defined cases and expected results to detect defects or variation.
- How it is used
- Protects prompt changes from behavioral regressions within a production prompt lifecycle.
- How deep it goes
- Defines manual checks, automated cases, and version-diff review; excludes large-scale structured quality evaluation.
- Examples
- Checks variable resolution and output format, and probes policy constraints with adversarially framed requests.
- What you can do after
- Diagnose/debug with it by catching execution failures and detecting unintended output changes after prompt edits.
Pro Angular 16
A unit test is an individual test that checks the behavior of an isolated software unit.
- How it is used
- Uses unit tests to examine Angular features, especially those that are difficult to implement or likely to cause bugs.
- How deep it goes
- Works from a basic Jasmine assertion through Angular component and directive tests covering bindings, events, properties, and rendered HTML.
- Examples
- Uses passing and failing Jasmine assertions, component tests, and an attribute directive applied through a test component.
- What you can do after
- Apply unit tests via Jasmine, Karma, and Angular testing utilities to check components, directives, bindings, events, and properties.
BDD in Action, Second Edition
An automated test is a software-based check that runs without manual execution to determine whether behavior meets specified expectations.
- How it is used
- Uses automated checks to verify acceptance criteria, protect existing behavior, and support reliable delivery of changes.
- How deep it goes
- Explains automation design, prioritization, and maintainability, while stopping short of detailed implementation code.
- Examples
- Uses Given-When-Then acceptance criteria, frequent-flyer points, critical user journeys, and BDD automation tools.
- What you can do after
- Build reliable acceptance-test suites that verify behavior, document scenarios, and detect regressions during change.
.NET in Action, Second Edition
Testing is the systematic evaluation of software behavior against expected functionality and correctness.
- How it is used
- Uses unit tests to verify software components and build confidence that code meets its intended behavior.
- How deep it goes
- Works from individual methods through xUnit facts, theories, input data, equality assertions, and exception checks.
- Examples
- Tests a Sudoku solver and checks that invalid board sizes throw an ArgumentException.
- What you can do after
- Apply via xUnit to write tests for inputs, expected results, and exceptions.
Quarkus in Action
A test is an automated or manual evaluation of software behavior against expected results.
- How it is used
- Uses automated checks to validate Quarkus behavior during development, JVM execution, native builds, and packaged application runs.
- How deep it goes
- Covers JUnit integration, execution modes, profiles, mocks, and endpoint assertions, but defers exhaustive test design guidance.
- Examples
- Demonstrates endpoint assertions, packaged-mode reuse, extension metadata checks, configuration overrides, and automatically managed test services.
- What you can do after
- Apply it via JUnit, REST Assured, Mockito, testing profiles, and Quarkus integration-test annotations.
Think Like a CTO
Testing is the systematic evaluation of software behavior or documented procedures by execution or review to reveal gaps and verify intended results.
- How it is used
- Checks whether developed or installed software behaves as expected through manual or automated testing.
- How deep it goes
- Explains independent testing, automated-test setup, and coverage priorities, while noting that exhaustive testing is impractical.
- Examples
- Uses a car-engine test to distinguish test quality from quantity and a record-deletion test to illustrate setup dependencies.
- What you can do after
- Evaluate test quality by considering crucial code coverage rather than relying on test counts alone.
Kafka for Architects
Unit testing is the testing of isolated software units, such as functions or classes, independently from their surrounding components.
- How it is used
- Verifies isolated Kafka application components before external message flow is validated through integration testing.
- How deep it goes
- Defines isolation, observable behavior, mocks, and Kafka boundaries, while stopping short of actual cluster and end-to-end behavior.
- Examples
- Uses ProfileService producer tests, Customer360Service handler tests, deserialized messages, return values, state changes, and mocked Kafka components.
- What you can do after
- Apply it via mocks or fakes to verify service behavior without a Kafka cluster or real network communication.
Design for Developers
Testing is the systematic evaluation of a design or product to determine its visual quality, usability, or other properties.
- How it is used
- Guides evaluation of visual design, usability, functionality, and business requirements within an iterative web project.
- How deep it goes
- Defines evaluation goals and timing, but stops short of naming specific testing methods or detailed procedures.
- Examples
- Uses a one-off marketing website, post-launch checks, client handoff, and an iterative process diagram.
- What you can do after
- Evaluate a live web design, identify unmet needs or requirements, and refine the project through another iteration.
Go in Practice, Second Edition
A test case is a defined set of inputs, conditions, and expected results for verifying software behavior.
- How it is used
- Uses unit tests to make Go applications more reliable and reduce production errors.
- How deep it goes
- Defines table-driven unit tests, demonstrates failure output, and stops short of broader testing such as accessibility or integration testing.
- Examples
- Uses a Fizz Buzz function, table-driven cases, go test failures, corrected expectations, and added inputs for 5 and 12.
- What you can do after
- Apply table-driven tests with Go's built-in testing tools to detect incorrect function results.
The Well-Grounded Rubyist, Fourth Edition
A test method is a method whose name begins with test and that contains executable assertions for a test case.
- How it is used
- Checks program behavior by running named methods containing assertions.
- How deep it goes
- Explains MiniTest naming, setup, and autorun, then implements test discovery with inheritance and method-added callbacks.
- Examples
- Tests one-card and five-card deals by asserting the deck’s remaining size.
- What you can do after
- Apply it by writing MiniTest methods that assert expected behavior and run automatically.
Read how The Well-Grounded Rubyist, Fourth Edition explains test →
Generative AI in Action
A test case is a defined combination of inputs, conditions, and expected results used to evaluate software behavior.
- How it is used
- Uses generated unit tests to check whether an OpenAI completion call and its printed output behave as expected.
- How deep it goes
- Walks through unittest setup, mocking, test methods, and execution, while warning that scenario coverage and maintainability remain limited.
- Examples
- Tests a mocked openai.completion.create() response and checks expected print strings.
- What you can do after
- Apply Python's unittest and mock to test an API call and printed output despite nondeterministic AI behavior.
Automating API Delivery
A unit test is an automated test that evaluates a small, isolated software unit independently of its external dependencies.
- How it is used
- Uses isolated automated checks to validate API controllers, schemas, and custom linting behavior.
- How deep it goes
- Explains fixtures, isolation, assertions, valid and invalid paths, and gateway limits without covering full-stack behavior.
- Examples
- Demonstrates controller responses, OpenAPI fixtures, operationId naming cases, expected diagnostics, and HTTP success or error paths.
- What you can do after
- Build isolated controller and linting-rule tests that assert API responses, schemas, diagnostics, paths, and severity.
Rust in Action: Systems programming concepts and techniques
Unit testing is the practice of testing individual program units in isolation against expected behavior.
- How it is used
- Verifies fixed-point conversions and boundary behavior during Rust development.
- How deep it goes
- Shows test modules, test attributes, assertions, and Cargo execution, without developing a broader testing strategy.
- Examples
- Uses Q7 conversion tests for f32 values, Q7-to-f32 values, and out-of-bounds inputs.
- What you can do after
- Apply it via Cargo to verify implementation behavior and identify failed unit tests.
Read how Rust in Action: Systems programming concepts and techniques explains test →
Effective Platform Engineering
Automated testing is the execution of software tests by tools or scripts with limited or no manual intervention.
- How it is used
- Uses automated tests to validate platform changes before release and to make every environment transition follow one repeatable pipeline.
- How deep it goes
- Explains test-first implementation, environment progression, test categories, and status checks, but does not detail individual test designs.
- Examples
- Uses test-first development, hidden early testing instances, preview environments, commit-based promotion, and pipeline-triggered throw-away instances.
- What you can do after
- Apply it via an automated pipeline that verifies behavior across environments before release and preserves consistent change identity.
Learn Haskell by Example
Testing is the process of evaluating software behavior to find defects or verify requirements.
- How it is used
- Uses tests to assess correctness, verify requirements, and protect software against regressions.
- How deep it goes
- Develops unit and property testing from motivation through random generation, QuickCheck usage, custom generators, and Stack integration.
- Examples
- Contrasts handcrafted input-output examples with randomly generated inputs checked against formalized properties.
- What you can do after
- Builds Haskell property tests with QuickCheck, custom generators, and Stack test suites.
gRPC Microservices in Go
Testing is the systematic evaluation of software behavior against expected results or properties.
- How it is used
- Accelerates microservice feedback, protects code quality, and reduces delivery and production defect costs.
- How deep it goes
- Explains strategies, test workflow phases, dependency choices, test pyramids, coverage, and CI verification without detailing framework internals.
- Examples
- Demonstrates Fibonacci assertions in Go and contrasts mocked or containerized MySQL dependencies for an Order service.
- What you can do after
- Apply it via go test, testify, mocks, or test containers to verify service scenarios and dependency integrations.
Julia as a Second Language
Software testing is the systematic evaluation of software behavior using prescribed inputs and expected results to detect defects and verify correctness.
- How it is used
- Protects package code from regressions after edits across multiple files.
- How deep it goes
- Covers basic setup, nested test sets, assertions, environments, execution, and one fix, while deferring broader testing practice.
- Examples
- Uses ToyGeometry trigonometric tests, sampled cosine and sine comparisons, failure summaries, and a corrected cosine approximation.
- What you can do after
- Operate Julia package tests through the package manager and diagnose failures using test summaries.
Building Reliable AI Systems
Testing is the systematic execution of queries or other inputs to assess a software system's behavior and identify defects.
- How it is used
- Validates coordination across multi-agent workflows rather than judging agents in isolation.
- How deep it goes
- Prioritizes coordination checks across blended queries, ambiguous intent, failures, and state continuity.
- Examples
- Uses blended queries, ambiguous intent, component failures, and state continuity as test scenarios.
- What you can do after
- Evaluate multi-agent workflows by checking coordination, failure handling, and state continuity.
Related concepts
- evaluation suitepart of · An evaluation suite is an organized collection of tests, cases, or tasks used to assess a system against specified behaviors or criteria.
- mockingcontrasts with · Mocking is a testing technique that replaces a real dependency with a controlled substitute to simulate behavior or inspect interactions.
- continuous integrationused by · Continuous integration is a software development practice in which code changes are integrated frequently into a shared codebase and automatically validated.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.