Edge Case Identification and Testing Questions

Focuses on systematically finding, reasoning about, and testing edge and corner cases to ensure the correctness and robustness of algorithms and code. Candidates should demonstrate how they clarify ambiguous requirements, enumerate problematic inputs such as empty or null values, single element and duplicate scenarios, negative and out of range values, off by one and boundary conditions, integer overflow and underflow, and very large inputs and scaling limits. Emphasize test driven thinking by mentally testing examples while coding, writing two to three concrete test cases before or after implementation, and creating unit and integration tests that exercise boundary conditions. Cover advanced test approaches when relevant such as property based testing and fuzz testing, techniques for reproducing and debugging edge case failures, and how optimizations or algorithmic changes preserve correctness. Interviewers look for a structured method to enumerate cases, prioritize based on likelihood and severity, and clearly communicate assumptions and test coverage.

HardSystem Design

82 practiced

Design an integration test harness for a data pipeline that validates schema, transformations, and invariants at scale. Explain how to generate synthetic large datasets with corner-case records (nulls, late-arriving records, out-of-order events, extreme values), how to run tests locally and in CI without processing petabytes, and what assertions you'd use to detect silent data corruption or semantic drift.

Sample Answer

Requirements:- Validate schema, transformation semantics, and invariants end-to-end.- Support corner cases (nulls, late/out-of-order, extremes).- Run locally/CI cheaply; scale tests for load/throughput sampling.- Detect silent corruption and semantic drift.

High-level architecture:Test harness composed of: Data Generator, Ingest Simulator, Transformation Runner (same pipeline code), Validator (assertions + metrics), Oracles/Golden datasets, CI Orchestrator.Data flow: Generator -> Ingest (Kafka/files) -> Pipeline -> Output store -> Validator.

Synthetic dataset strategy:- Mix deterministic seeds + property/fuzz rules so tests are reproducible.- Produce small focused batches for CI (1–100k rows) and larger samples for nightly performance tests (GBs).- Include corner-case templates: null-heavy rows, late timestamps (timestamp - delta > watermark), out-of-order windows, extreme numeric/string values, maximum-length strings, invalid enum codes, duplicate keys, partial records.- Use combinatorial test matrix to ensure edge coverage rather than brute force scale.

Example generator (reproducible, seeded, corner cases):

python

import random, uuid, time
random.seed(42)

def gen_row(i):
    base_ts = int(time.time()*1000)
    return {
      "id": str(uuid.uuid4()) if i%13 else None,           # null id once every 13
      "value": 10**9 if i%97==0 else random.uniform(-1e6,1e6),  # extreme occasionally
      "event_ts": base_ts - (i%7)*60000 if i%11==0 else base_ts + (i%5)*1000, # late/out-of-order
      "status": random.choice(["OK","WARN","ERR", "UNKNOWN"]) if i%29 else "INVALID"
    }

Running locally and in CI:- Local: run harness with small deterministic seed, wire up to localKafka/local files, run pipeline in-process or with Docker compose for services. Fast unit/integration path uses in-memory runner.- CI: run schema + transformation contract tests and property tests (many randomized seeds but limited rows). Use parallel seeds to increase coverage. Nightly/regression pipeline runs larger synthetic loads in a scaled environment or emulated clusters.- Avoid petabytes by sampling and by using statistical amplification: run extensive small-case combinatorial tests + a few large-but-bounded performance scenarios.

Validators & assertions:1. Schema conformance: strict schema registry checks, missing/extra fields, types, nullability.2. Checksum/hashing: compute column-level hash signatures (e.g., ordered canonical serialization then SHA256) on inputs and expected transforms to detect silent corruption.3. Row-level invariants: primary-key uniqueness, referential integrity (foreign-key counts), non-negative balances.4. Distributional assertions: compare histograms and summary stats (count, min, max, mean, stddev, percentiles) vs baseline using KS test / chi-square with thresholds to detect semantic drift.5. Watermark/timeliness: assert late-event percentages within SLAs, acceptable reorder windows.6. Duplicate and idempotency: detect rows reprocessed more than N times.7. Domain rules: enums limited set; business-specific checks (sum of debits == credits).8. Contractual transformation assertions: for sampled input -> expected output mapping run a golden-transform oracle for small inputs.

Detecting semantic drift:- Maintain rolling baselines (weekly snapshots of stats). Run statistical divergence (JS divergence / KS) with alert thresholds and explainability: per-column drift contributors.- Use model-based invariants: train lightweight classifiers/regressors on historical data; large drop in score for synthetic-known-good data or real data flags drift.

Scalability & trade-offs:- Trade-off between coverage and cost: favor many small deterministic tests + periodic large-scale runs.- Deterministic seeds ensure reproducibility; randomization increases coverage — combine both.- For heavy-scale validation, use sampling, probabilistic data structures (bloom, HyperLogLog) for cardinality, and sketch-based histograms.

Operational notes:- Integrate validators into CI pipelines as gating checks and into monitoring for production with sliding-window checks and automatic rollback.- Store test artifacts (input seeds, output snapshots, hashes) for audits and debugging.

MediumTechnical

78 practiced

Implement a robust integer parser safeParseInt(String s) in Java that handles leading/trailing whitespace, optional '+'/'-' signs, empty or null inputs, non-digit characters, and detects 32-bit integer overflow without relying on BigInteger. Before coding, list the edge-case tests you would write and the behavior (e.g., return Optional.empty() or throw NumberFormatException).

Sample Answer

Approach:- Trim whitespace, handle null/empty, parse optional +/- sign, iterate digits accumulating in a long-like check using int bounds to detect overflow without BigInteger. On invalid input return Optional.empty() (safer than throwing) — but note I’ll show throwing variant as comment.

Edge-case tests and expected behavior:- null -> Optional.empty()- "" (empty) -> Optional.empty()- " " -> Optional.empty()- "+" -> Optional.empty()- "-" -> Optional.empty()- "123" -> Optional.of(123)- "+123" -> Optional.of(123)- "-123" -> Optional.of(-123)- "0000123" -> Optional.of(123)- "2147483647" (INT_MAX) -> Optional.of(2147483647)- "-2147483648" (INT_MIN) -> Optional.of(-2147483648)- "2147483648" -> Optional.empty() (overflow)- "-2147483649" -> Optional.empty() (underflow)- "12a34" -> Optional.empty()- " -42 " -> Optional.of(-42)- "+-2" -> Optional.empty()- " + 1" -> Optional.empty()

Implementation:

java

import java.util.Optional;

public class SafeParser {
    public static Optional<Integer> safeParseInt(String s) {
        if (s == null) return Optional.empty();
        s = s.trim();
        if (s.isEmpty()) return Optional.empty();

        int i = 0, n = s.length();
        int sign = 1;
        char c = s.charAt(0);
        if (c == '+' || c == '-') {
            sign = (c == '-') ? -1 : 1;
            i++;
            if (i == n) return Optional.empty(); // only sign, no digits
        }

        int result = 0;
        final int INT_MAX = Integer.MAX_VALUE;
        final int INT_MIN = Integer.MIN_VALUE; // negative
        while (i < n) {
            c = s.charAt(i++);
            if (c < '0' || c > '9') return Optional.empty();
            int digit = c - '0';

            // Check overflow before multiplying by 10:
            if (sign == 1) {
                if (result > (INT_MAX - digit) / 10) return Optional.empty();
                result = result * 10 + digit;
            } else {
                // accumulate as negative to handle MIN correctly
                if (result < (INT_MIN + digit) / 10) return Optional.empty();
                result = result * 10 - digit;
            }
        }
        return Optional.of(result);
    }

    // Throwing variant:
    // public static int parseIntOrThrow(String s) { return safeParseInt(s).orElseThrow(NumberFormatException::new); }
}

Key points:- Avoids BigInteger by checking overflow with inequalities before multiply/add.- Accumulates negative when sign is negative to correctly handle Integer.MIN_VALUE.Time complexity: O(n) where n = length of string. Space: O(1).

Alternative: Use long accumulator and compare to bounds, then cast; behavior choice (Optional vs exception) depends on API expectations.

EasyTechnical

101 practiced

An API doc says '0 < limit <= 100' for a query parameter limit. How would you clarify ambiguities and enumerate test inputs for boundary and invalid cases? Provide at least eight inputs (e.g., -1, 0, 1, 100, 101, '50', '1e2', '', extremely long numeric string) and expected server behaviors or error codes. Discuss security concerns for extremely long or malformed numeric strings.

EasyTechnical

95 practiced

Compare how Java, Python, and JavaScript handle empty, null/None/undefined, and missing elements for arrays/lists. Provide short code examples that show failures or surprising behavior in each language, and list unit tests you would add to ensure a function that processes collections behaves correctly across these cases.

Sample Answer

High-level comparison:- Java: statically typed; arrays/lists can't contain "missing" slots — elements can be null. Accessing null causes NullPointerException. Primitive arrays can't hold null.- Python: dynamic; lists can contain None. Indexing out of range raises IndexError. Iterating over None elements is harmless unless you call methods on them.- JavaScript: arrays can have undefined holes (sparse arrays) and elements can be undefined or null. Accessing missing index yields undefined; some array methods skip holes.

Surprising/failure examples:

Java (NullPointerException)

java

import java.util.*;
List<String> list = Arrays.asList("a", null, "c");
for (String s : list) {
    System.out.println(s.toUpperCase()); // NPE when s==null
}

Python (IndexError / None)

python

lst = ["a", None, "c"]
for s in lst:
    print(s.upper())  # AttributeError when s is None

print(lst[10])  # IndexError: list index out of range

JavaScript (sparse arrays / skipped holes)

javascript

let arr = ["a", , "c"]; // hole at index 1
console.log(arr[1]); // undefined
arr.forEach(x => console.log(x.toUpperCase())); // TypeError when x is undefined for that slot? forEach skips holes, so no call
// but map will produce holes preserved
console.log(arr.map(x => x && x.toUpperCase())); // [ 'A', , 'C' ]

Unit tests to add for a function processCollection(coll):- Input none/null/undefined → expect empty-result or specific error- Empty collection → returns empty-result- Collection with only null/None/undefined elements → handled without throwing- Mixed valid and null/None/undefined elements → valid processed, nulls skipped or handled- Sparse arrays (JS) → behavior for holes: treated as undefined or preserved- Out-of-range indexing (Python) → function shouldn't index blindly- Collection with primitives vs objects (Java) → handle primitive arrays vs boxed types- Performance test for large collections (optional)

MediumTechnical

90 practiced

Design tests for a paginated API that supports both offset/limit and cursor-based pagination. Include edge cases such as empty result sets, page boundary items, items added or deleted between page requests, limit=0 or >max, and duplicated or missing items across pages. Describe integration tests, consistency checks, and how to simulate concurrent writes during pagination in tests.

Sample Answer

Approach: cover both pagination modes with deterministic fixtures, integration tests against a real or test DB, plus fuzz/consistency checks and concurrency simulation.

Test types and cases:- Basic correctness - Request pages with offset/limit and cursor; assert union of pages equals full dataset sorted by canonical key.- Empty result sets - Dataset size 0; request page -> 200 with empty list.- Page boundaries - Page size that exactly divides total, one-off (total+1), and last partial page. Assert no overlap/omission.- limit=0 and limit>max - limit=0 -> 400 or normalized to default; >max -> capped to MAX_LIMIT; assert behavior matches spec.- Duplicated/missing items - Create items with identical sort keys; ensure stable secondary tie-breaker (id) and no dupes across pages.- Items added/deleted during pagination - Start paginated read, concurrently insert/delete items; tests assert either strong-consistency snapshot semantics or explain eventual-consistency behavior.

Integration tests / consistency checks:- Full-scan equivalence: fetch all items in one request (if allowed) or aggregate all pages; compare to direct DB query result using same ordering.- Idempotency and ordering: repeated fetches produce same ordered ids if DB snapshotting expected.- Uniqueness invariant: set(all_ids_across_pages) length equals sum lengths.

Simulating concurrent writes (example using Python + threading against test DB):

python

import threading, requests, time

def paginate_collect(url, params, out):
    while True:
        r = requests.get(url, params=params).json()
        out.extend(r['items'])
        if not r.get('next_cursor'): break
        params['cursor']=r['next_cursor']

def writer(api_url):
    for i in range(10):
        requests.post(api_url, json={'value':f'x{i}'})
        time.sleep(0.05)

items=[]
p = {'limit':5}
t_writer = threading.Thread(target=writer, args=('http://test/api/items',))
t_reader = threading.Thread(target=paginate_collect, args=('http://test/api/items', p, items))
t_writer.start(); t_reader.start()
t_writer.join(); t_reader.join()
# Assertions: depending on spec, either no missing/duplicates against snapshot or allow added items only after snapshot.

Practical tips:- Use deterministic timestamps or version numbers as cursors; include stable tie-breaker (id).- For offset mode, test high offsets and performance caps.- For cursor mode, test invalid/expired cursors, and replaying cursor after writes.- For eventual-consistency APIs, assert documented guarantees (e.g., "new items may appear or be skipped") rather than strict equality.

Unlock Full Question Bank

Get access to hundreds of Edge Case Identification and Testing interview questions and detailed answers.

Join thousands of developers preparing for their dream job.