Why Every Automation Tester Must Learn NumPy This Year

# Compare two numeric datasets (e.g., from CSV)
import numpy as np

expected = np.array([1.0, 2.5, 3.7, 4.9, 5.1])
actual   = np.array([1.0, 2.5, 3.7, 4.9, 5.1])

# Exact comparison
if np.array_equal(expected, actual):
    print("PASS: datasets match exactly")
else:
    print("FAIL: differences found")

# Difference report
diff = expected - actual
mismatches = np.where(diff != 0)[0]
print("Mismatch indices:", mismatches)

# For floating-point data, exact equality is wrong.
# Use tolerance-based comparison instead.

import numpy as np

expected = np.array([0.1, 0.2, 0.3])
actual   = np.array([0.1000001, 0.2000002, 0.3000001])

# allclose respects floating-point error
assert np.allclose(expected, actual, atol=1e-6), "Values differ beyond tolerance"

# Check element-wise absolute difference
diffs = np.abs(expected - actual)
print("Max diff:", diffs.max())

# Test: every value within 1e-5
if np.all(diffs < 1e-5):
    print("PASS: all values within tolerance")

# Assert API latency stays within acceptable bounds
import numpy as np

latencies_ms = np.array([120, 135, 110, 150, 200, 95, 180, 130])

# 95th percentile should stay under 250ms
p95 = np.percentile(latencies_ms, 95)
assert p95 < 250, f"p95 latency too high: {p95}ms"

# Average should stay under 160ms
avg = np.mean(latencies_ms)
assert avg < 160, f"avg latency too high: {avg}ms"

# No single request should exceed 500ms
assert latencies_ms.max() < 500, "spike detected"

print(f"PASS: p95={p95}ms, avg={avg}ms")

# Count errors and detect patterns in log data
import numpy as np

status_codes = np.array([200, 200, 200, 500, 200, 404, 200, 500])

# Count of 5xx errors
server_errors = np.sum(status_codes >= 500)
assert server_errors == 0, f"{server_errors} server errors detected"

# Count of 4xx errors
client_errors = np.sum((status_codes >= 400) & (status_codes < 500))
print(f"4xx errors: {client_errors}")

# Unique status codes observed
print("Codes seen:", np.unique(status_codes))

# Compare two screenshots pixel by pixel
import numpy as np
from PIL import Image

img_a = np.array(Image.open("baseline.png"))
img_b = np.array(Image.open("current.png"))

# Ensure both images have the same shape
assert img_a.shape == img_b.shape, "Image sizes differ"

# Element-wise absolute difference
diff = np.abs(img_a.astype(int) - img_b.astype(int))

# Total number of pixels that changed
changed_pixels = np.sum(diff > 0)
total_pixels = diff.size

print(f"Changed pixels: {changed_pixels} / {total_pixels}")

# Fail the test if more than 1% changed
if changed_pixels / total_pixels > 0.01:
    raise AssertionError("Visual regression detected")

# Allow small tolerance (anti-aliasing, minor rendering)
import numpy as np
from PIL import Image

img_a = np.array(Image.open("baseline.png"))
img_b = np.array(Image.open("current.png"))

diff = np.abs(img_a.astype(int) - img_b.astype(int))

# Per-channel threshold
THRESHOLD = 30  # out of 255

# A pixel counts as "changed" only if any channel exceeds threshold
meaningful_diff = np.any(diff > THRESHOLD, axis=-1)
changed_pixels = np.sum(meaningful_diff)

if changed_pixels > 100:
    raise AssertionError(f"{changed_pixels} pixels differ significantly")

print("PASS: images match within tolerance")