Cross-Browser and Cross-Platform Testing Questions

Approach: build a deterministic harness that (1) generates reproducible inputs, (2) runs the numerical algorithm multiple times with controlled environment, (3) compares outputs using both absolute/relative thresholds and ULP distance, (4) collects metadata (compiler, flags, CPU features, math libs) and (5) reports failures and mitigation suggestions.

C++ test harness (core comparison + reproducible RNG + ULP):

#include <random>
#include <vector>
#include <cmath>
#include <cstdint>
#include <iostream>
#include <cstring>

using vec = std::vector<double>;

// reproducible input generator
vec gen_inputs(size_t n, uint64_t seed=123456789){
    std::mt19937_64 rng(seed);
    std::uniform_real_distribution<double> d(-1e3, 1e3);
    vec v; v.reserve(n);
    for(size_t i=0;i<n;i++) v.push_back(d(rng));
    return v;
}

// double -> uint64 bitcast
uint64_t bits(double x){ uint64_t b; std::memcpy(&b,&x,sizeof b); return b; }
// ULP distance (works for non-NaN)
uint64_t ulp_dist(double a, double b){
    if(std::isnan(a)||std::isnan(b)) return UINT64_MAX;
    int64_t ia = (int64_t)bits(a);
    if(ia<0) ia = INT64_MIN - ia;
    int64_t ib = (int64_t)bits(b);
    if(ib<0) ib = INT64_MIN - ib;
    return (uint64_t) (ia>ib ? ia-ib : ib-ia);
}

bool almost_equal(double a, double b, double abs_tol, double rel_tol, uint64_t max_ulp){
    if(std::isnan(a)||std::isnan(b)) return false;
    if(std::isinf(a)||std::isinf(b)) return a==b;
    double diff = std::fabs(a-b);
    if(diff <= abs_tol) return true;
    if(diff <= rel_tol * std::max(std::fabs(a), std::fabs(b))) return true;
    return ulp_dist(a,b) <= max_ulp;
}

Key concepts and policy:

• Reproducible inputs: fixed RNG seed + store test vectors (binary files/checksums) so different machines use identical inputs.
• Comparison metrics: use absolute (e.g., 1e-12), relative (1e-12), and ULP (e.g., <=4 ULP) thresholds. Choose based on algorithm scale and conditioning.
• Metadata: record compiler (version, flags), -ffast-math, glibc/libm, CPU features (SSE/AVX, rounding modes), OS, timestamp and checksum of inputs.
• Cross-platform runners: produce a small self-contained binary; use CI matrix (GitHub Actions, Azure Pipelines) to run on compiler/arch combos; collect JSON reports to central server; use Docker for reproducible environments.
• Re-run strategy: if discrepancy, re-run with controlled flags: disable optimizations and fast-math, set IEEE rounding (e.g., -frounding-math), use higher precision (long double) or libm with correctly-rounded functions.
• Mitigations when unacceptable:
  • Use higher precision types (long double, __float128) or compensated algorithms (Kahan summation).
  • Use fixed-point or decimal libraries for financial/regulated computations.
  • Implement deterministic math via software-emulated libm or providE reference implementation.
  • Add tolerant assertions in tests with documented tolerances; fail loudly when exceeded and attach metadata.

Operational tips:

• Classify tests: bit-exact (must match bits) vs numerically-robust (allow ULP tolerance).
• Automate regression: store canonical outputs and run nightly cross-platform verification.
• When narrowing root cause, bisect: change compiler flags, disable vectorization, increase precision to identify where differences originate.

Situation: At my last company I led frontend work for a consumer shopping product delivered as a React web app and React Native apps for Android/iOS. We needed consistent business logic, shared product catalog and cart behavior, but native UIs and platform-specific features (payments, push, deep links).

Task: Decide what to share, ensure compatibility, and create reliable CI/build/test pipelines.

Action:

• Code-sharing strategy: Created a monorepo (Yarn workspaces). Shared pure TypeScript packages for domain logic (pricing, promotions, validation), API client, and types. UI components lived in platform-specific packages: React web components and React Native components that consumed the same shared logic. Where native functionality was required (camera, payments), we wrapped platform differences behind a small adapter interface in the shared package and implemented adapters per platform.
• Testing across environments: Unit tests with Jest for shared logic. Web E2E with Cypress and component tests with React Testing Library. Mobile E2E with Detox on emulators and a device farm (AWS Device Farm) for real-device coverage. We used BrowserStack for cross-browser checks (Chrome, Firefox, Safari, Edge) across OS versions.
• Build & CI considerations: CI pipeline in GitHub Actions. Matrix builds: web, android, ios. Caching for node_modules and Gradle, parallel jobs for faster feedback. Android artifacts built with Gradle, iOS with fastlane for code signing and TestFlight distribution. Publish shared packages to an internal npm registry on tag merge. Enforced linting, type checks, and test thresholds as required CI gates.
• Compatibility problems & solutions:
  • Floating-point price rounding differences between JS engines: moved all money calculations to integer cents in shared logic and added strict unit tests.
  • Date/time timezone bugs on iOS WebView vs native: standardized on ISO strings and used date-fns with explicit UTC handling in shared layer.
  • Styling differences (e.g., font metrics, touch targets): built a design-token package with platform mappings; web used rem-based tokens, mobile used dp-scaled equivalents.
  • Web-specific accessibility: added ARIA attributes and keyboard focus management in web components; mobile got native accessibility props mapped from tokens.
  • Push notifications: abstracted registration and payload handling into adapter; unified payload schema in shared types.
    Result: Reduced duplicated logic by ~60%, eliminated several cross-platform bugs before release, increased E2E coverage to 85%, and accelerated release cadence—web and mobile releases synchronized within the same sprint with far fewer regressions.

Learning: Share pure logic and types, abstract platform differences behind small interfaces, invest in device/browser automated testing, and optimize CI with caching and parallelism to keep feedback fast.