5 exercises on the adverbs that define quality standards in software testing — from writing individual assertions to structuring an entire test suite. Essential vocabulary for QA engineers, developers, and anyone writing test documentation.
validate strictly — no type coercion, no extra properties, reject anything non-conforming
assert explicitly — name the exact expected value; no vague truthy checks
isolate completely — zero real external dependencies in a unit test
run in parallel — distribute across multiple runners simultaneously to reduce CI time
0 / 5 completed
1 / 5
A QA engineer writes in the team wiki:
"Our test suite must ___ test the payment flow — happy path (successful payment), declined card, network timeout, duplicate submission, and all documented edge cases. Partial testing is not acceptable for a PCI-scope service."
Which adverb means testing that covers all cases, paths, and edge cases in full depth?
Test thoroughly is the standard collocation for comprehensive testing that leaves no significant path or scenario untested.
review thoroughly — a PR review that checks logic, tests, security, style, and documentation
document thoroughly — all parameters, error codes, examples, and caveats covered
The adverb "thoroughly" implies completeness and depth — not just running the tests but designing them to cover what matters. In regulated domains (PCI-DSS, HIPAA, SOC 2), "tested thoroughly" appears in audit documentation as evidence of due diligence. Contrast: test superficially = only happy path, no edge cases; test automatically = using CI/CD without human intervention (describes the mechanism, not coverage depth). "Quickly" is about speed — the opposite of the intent here. "Independently" means without interference from other components — a different quality attribute.
2 / 5
A TypeScript library's contributing guide states:
"All schema parsing functions must ___ validate their inputs. Do not accept additional properties, do not coerce types silently — if the input is malformed, throw a typed error immediately."
Which adverb describes validation that rejects anything not explicitly conforming to the schema?
Validate strictly means enforcing schema rules without tolerance for deviation — no type coercion, no extra properties, no partial matches. It is the adverb for rigorous input validation.
Strict validation collocations in engineering:
validate strictly — zod.strict(), JSON Schema with additionalProperties: false, Pydantic with model_config = {"extra": "forbid"}
type strictly — TypeScript strict: true in tsconfig; no implicit any
enforce strictly — ESLint rules with error not warn
Contrast: validate loosely = accept approximate matches, coerce types (e.g., "123" as 123), ignore extra fields. Loose validation is easier to implement but produces hard-to-debug bugs when upstream data changes. "Automatically" describes the trigger, not the strictness. "Completely" is a synonym for "fully/100%" — close but "strictly" is the exact technical term for schema rigidity.
3 / 5
A testing best-practices document states:
"In unit tests, always ___ assert — name every assertion, never use bare assert True when assertEqual(result, expected_value) is possible. Vague assertions make test failures impossible to diagnose."
Which adverb means making assertions with specific, named expected values rather than vague boolean checks?
Assert explicitly means writing assertions that state exactly what value, type, or condition is expected — not just that something is truthy or falsy.
Examples of explicit vs. implicit assertions:
Explicit: expect(user.role).toBe("admin") — clear failure message when it breaks
Implicit: expect(!!user.role).toBe(true) — passes for any truthy role, including "guest"
Explicit: assertRaises(ValueError, parse_date, "not-a-date") — names the exact exception expected
The adverb "explicitly" signals that nothing is left to inference. Related uses:
declare explicitly — TypeScript: prefer explicit return types over inference
configure explicitly — no magic defaults; every option named
import explicitly — named imports over wildcard imports (import * as)
"Assert correctly" is redundant — all assertions should be correct. "Assert thoroughly" means covering all cases (number of assertions), not the quality of each assertion.
4 / 5
A microservices testing guide explains the recommended approach for unit tests:
"Unit tests must ___ isolate the code under test. All external dependencies — database connections, HTTP clients, message queues — must be replaced with test doubles. A unit test that calls the real database is an integration test."
Which adverb conveys that isolation must be total — no real external dependencies allowed?
Isolate completely means that every external dependency is replaced — no real network calls, no real database, no real filesystem. The unit under test has zero contact with external systems.
Testing isolation patterns:
isolate completely — mocks, stubs, fakes, and spies replace all I/O; test runs in memory only
mock cleanly — mock only what is necessary, restore mocks after each test (Jest afterEach(() => jest.restoreAllMocks()))
decouple completely — dependency injection enables complete isolation: new UserService(mockRepo)
The word "completely" is essential: "isolate cleanly" means tidily (no side effects left over) — a different quality. "Isolate carefully" implies caution, not totality. In test pyramid terminology: unit tests isolate completely; integration tests allow some real dependencies; end-to-end tests use real everything. A test that does not isolate completely is by definition not a pure unit test.
5 / 5
A CI configuration comment explains how the test suite is structured:
"We split the 3,000 test suite into 10 shards and run them ___ across 10 GitHub Actions runners. Total test time drops from 25 minutes to under 3 minutes."
Which adverb describes tests executing across multiple machines at the same time?
Run in parallel is the standard phrase for distributing work across multiple machines, threads, or processes so they execute simultaneously — the key technique for reducing CI build times.
Parallel test execution patterns:
run in parallel — test sharding (Jest --shard), pytest-xdist, GitHub Actions matrix strategy
execute in parallel — Promise.all(), Python concurrent.futures.ThreadPoolExecutor
run concurrently — often used interchangeably with "in parallel" in CI/CD documentation
Note: "run in parallel" is a prepositional phrase used adverbially — it is the established collocation, not "run parallelly". Related term: parallelise (British) / parallelize (American) — "we parallelised the test suite to cut CI time from 25 to 3 minutes." "Run independently" means each test does not depend on others (also important, but describes test design not execution model). "Run automatically" describes CI triggering, not concurrency. "Run sequentially" is the opposite — one shard at a time.