Parameterized और data-driven tests क्या हैं?

Question

Accepted Answer

**Parameterized (data-driven) tests** **एक ही test logic को inputs और expected outputs के कई sets के साथ** चलाते हैं — हर case के लिए test को duplicate करने से बचते हैं। ये कई scenarios (edge cases सहित) को संक्षेप में test करना आसान बनाते हैं।

## समस्या: duplicated tests

```text
Without parameterization, testing many input/output cases means COPYING the test:
  test('add 2+3', () => expect(add(2,3)).toBe(5));
  test('add 0+0', () => expect(add(0,0)).toBe(0));
  test('add -1+1', () => expect(add(-1,1)).toBe(0));
  → lots of near-identical, repetitive tests (tedious, hard to maintain)
```

## Parameterized tests — एक test, कई cases

```js
// run the SAME test logic over a TABLE of cases (Jest's test.each)
test.each([
  [2, 3, 5],
  [0, 0, 0],
  [-1, 1, 0],
  [100, 200, 300],
])('add(%i, %i) === %i', (a, b, expected) => {
  expect(add(a, b)).toBe(expected);     // one logic, run per case
});
// → each row is a separate reported test case; add a case = add a row
```

अधिकांश frameworks इसका समर्थन करते हैं (Jest `test.each`, pytest `@parametrize`, JUnit `@ParameterizedTest`)।

## लाभ

```text
✓ CONCISE — test many scenarios without duplicating the test body
✓ Easy to ADD CASES — just add a row of data (great for edge cases / many inputs)
✓ Each case reported SEPARATELY — you see exactly which input failed
✓ Clear, maintainable — the data table documents the cases
→ Ideal for functions with many input/output combinations and edge cases.
```

## यह क्यों महत्वपूर्ण है

Parameterized (data-driven) tests को समझना valuable है क्योंकि ये **कई scenarios को संक्षेप में test करना आसान बनाते हैं**, जो thorough testing (विशेष रूप से edge cases) का समर्थन करता है, इसलिए यह उपयोगी व्यावहारिक knowledge है।

वे जो समस्या हल करते हैं — कई input/output combinations को test करना अन्यथा **हर case के लिए test को duplicate करने** की आवश्यकता होती (tedious, repetitive, maintain करने में कठिन) — वास्तविक है, और parameterized tests **एक ही test logic को cases की एक table पर** चलाकर इसे संबोधित करते हैं।

यह कई scenarios को test करना **concise** बनाता है (एक test body, कई cases), cases जोड़ना **आसान** बनाता है (बस data की एक row जोड़ें — जो अधिक inputs और **edge cases** test करने को प्रोत्साहित करता है, उस thorough edge-case coverage का समर्थन करता है जो bugs पकड़ती है), **प्रत्येक case को अलग से** report करता है (ताकि आप ठीक देखें कि कौन सा input fail हुआ, debugging में सहायता करता है), और tests को maintainable रखता है (data table स्पष्ट रूप से cases को document करती है)।

यह समझना कि अधिकांश frameworks इसका समर्थन करते हैं (Jest का `test.each`, pytest का `@parametrize`, JUnit का `@ParameterizedTest`) इसे stacks में व्यावहारिक रूप से लागू बनाता है।

Parameterized tests कई input/output combinations वाले functions के लिए आदर्श हैं — utility functions, validators, parsers, और calculations के लिए सामान्य — जहाँ वे duplicated test code के बोझ के बिना cases की पूरी range (boundaries और edge cases सहित) को test करना सक्षम करते हैं।

broad input coverage प्राप्त करने का यह concise, maintainable तरीका अधिक thorough testing को प्रोत्साहित करता है।

चूँकि कई scenarios (विशेष रूप से edge cases) को test करना thorough testing के लिए महत्वपूर्ण है और parameterized tests इसे concise और maintainable बनाते हैं (duplicated tests से बचना, broad input coverage को प्रोत्साहित करना), और चूँकि इन्हें और इनके framework support को समझना प्रभावी testing के लिए उपयोगी है, इसलिए parameterized और data-driven tests को समझना valuable, व्यावहारिक रूप से प्रासंगिक knowledge है — कई cases को संक्षेप में test करने की एक उपयोगी तकनीक, उस thorough edge-case coverage का समर्थन करती है जिसकी प्रभावी testing को आवश्यकता होती है, और जहाँ भी functions में सत्यापित करने के लिए कई input/output combinations होते हैं वहाँ लागू एक handy tool।