DEV Community: Shivang Vora

A Developer's Guide to Test Case Generation with Genetic Algorithms

Shivang Vora — Sat, 22 Nov 2025 12:47:42 +0000

As developers, we often face the challenge of testing functions with complex business logic and numerous parameters. How can we be sure we've covered all the tricky edge cases and interactions between different inputs? Manually writing these tests is tedious, and a simple brute-force approach can lead to a combinatorial explosion of test cases.

This is where a smarter approach, like using a Genetic Algorithm (GA), can be a game-changer. In this article, I'll walk through a project that uses a GA to automatically generate a concise and effective set of test cases for a complex e-commerce pricing function, explaining the core logic step-by-step.

The System Under Test: A Complex Pricing Function

To demonstrate the power of the GA, we need a sufficiently complex function. In my experiment, I used a Python function that calculates the final price of a product. It involves various rules: percentage discounts, flat-rate discounts, "Buy One, Get One" (BOGO) offers, membership-level bonuses, and promotional codes.

Here is the signature and some of the validation logic:

def calculate_final_price(
    base_price, 
    discount_type, 
    discount_value, 
    membership_level,
    cart_total,
    promo_code,
    product_category
):
    # --- A few example validation checks ---
    if base_price <= 0:
        raise ValueError("Invalid base price.")

    if discount_type == 'flat' and discount_value >= base_price:
        raise ValueError("Flat discount too high.")

    if promo_code == 'SAVE10' and cart_total < 100:
        raise ValueError("Promo code SAVE10 requires $100+ cart.")

    if discount_type == 'bogo' and product_category not in ['apparel', 'accessories']:
        raise ValueError("BOGO only valid for apparel and accessories.")
    # ... and many more ...

    final_price = base_price
    # ... apply discounts based on logic ...

    return round(final_price, 2)

Generating test cases for this is difficult. A 'bogo' discount is only valid for 'apparel', and the 'SAVE10' promo code requires a cart_total over $100. A random approach would generate mostly invalid inputs that raise ValueError, failing to test the actual pricing logic. Our goal is to find inputs that pass these checks.

Evolving Valid Test Cases with a Genetic Algorithm

Instead of generating inputs blindly, we can use a GA to "evolve" a population of test cases. The algorithm learns the function's rules and produces a set of "fit" individuals that successfully exercise the logic. Let's break down the code.

Step 1: Defining "Fitness"

First, we need to quantify how "good" a test case is. In our scenario, a test case is good if it's valid—meaning it doesn't cause the function to raise an exception. We create a fitness function that rewards these valid inputs.

def fitness(test_case):
    try:
        # Attempt to run the function with the given test case
        calculate_final_price(*test_case)
        # If it succeeds, the test case is valid and "fit"
        return 10
    except ValueError as e:
        # If it fails, the test case is invalid and "unfit"
        return 1

This is the core of our "learning" process. By giving a higher score (10) to test cases that run successfully, we tell the algorithm which individuals should be prioritized for creating the next generation.

Interestingly, if we flip the fitness logic by setting a higher score for errors, we get output test cases that are the best at failing!

Step 2: The Genetic Operators - Crossover and Mutation

Genetic Algorithms are inspired by evolution. We need mechanisms for "reproduction" (crossover) and random change (mutation).

Crossover combines two successful parent test cases to create a new "child." Our implementation uses uniform crossover: for each parameter, it randomly chooses the value from one of the two parents. This allows good traits (valid parameter combinations) from different parents to be mixed.

def crossover(p1, p2):
    # For each parameter, randomly choose the value from parent 1 or parent 2
    return [random.choice(x) for x in zip(p1, p2)]

Mutation introduces new genetic material into the population, preventing it from getting stuck. Our mutate function takes a test case and replaces one of its parameters with a new, completely random value. This helps explore new possibilities that crossover alone might not discover.

def mutate(tc):
    # Pick a random parameter index to change
    i = random.randint(0, len(tc)-1)
    # Replace it with a new, fully random value for that parameter type
    tc[i] = random_test_case()[i]
    return tc

Step 3: The `evolve` Loop - Simulating Natural Selection

The evolve function orchestrates the entire process, running the simulation for a set number of generations.

def evolve(pop_size=50, generations=10):
    # 1. Initialize a random population
    population = [random_test_case() for _ in range(pop_size)]

    for _ in range(generations):
        # 2. Score each individual in the population
        scored = [(fitness(tc), tc) for tc in population]

        # 3. Sort by fitness (fittest first)
        scored.sort(reverse=True)

        # 4. Select the top 50% (elitism) to be the parents
        population = [tc for _, tc in scored[:pop_size//2]]

        # 5. Generate new children to replenish the population
        children = []
        while len(children) < pop_size:
            # Pick two random parents from the elite group
            p1, p2 = random.sample(population, 2)
            child = crossover(p1, p2)

            # 30% chance to mutate the child
            if random.random() < 0.3:
                child = mutate(child)

            if child not in children:
                children.append(child)

        population = children

    # Finally, return the 10 fittest individuals found
    return sorted([(fitness(tc), tc) for tc in population], reverse=True)[:10]

Over several generations, the population gets progressively better. Unfit individuals that cause errors are weeded out, while fit individuals are combined and mutated to discover new, valid test cases that explore the function's different logical paths.

The Result: A Curated Set of Intelligent Tests

After the evolution is complete, we get a small, curated list of high-quality test cases. These aren't just random inputs; they are diverse, valid scenarios that the GA discovered on its own. They represent a smart, automatically generated test suite for our complex function.

This project demonstrates that GAs can be a powerful tool for search-based software testing. By intelligently navigating the vast search space of possible inputs, they can deliver a concise suite of tests that are tailored to the specific logic of the code.

The full implementation can be found in the Jupyter Notebook on GitHub. Dive in and see the evolution in action!

Disruption and Restoration: A Python Solution for Fragmenting and Defragmenting Files.

Shivang Vora — Fri, 15 Mar 2024 05:48:32 +0000

Motivation, the why?

As a weekend project I wanted to explore the idea of making a file fragmenting and defragmenting system that divides the original file into smaller packets which are individually salted and when needed can be used together to return the original data.

To add a ✨flare of drama✨ to the reading experience, while going through this,
if you could imagine the divided packets as legendary rings which are given to a few skilled and trusted warriors who will one day have to come together and use the rings as keys to unlock some forbidden knowledge
or
as USB drives sworn to be protected by secret agents who directly report to the president and when the time is right (or the leader is trigger happy) together will unlock the nuclear launch codes.

your dedication to the bit would be much appreciated.

Overview, the what?

To give an overview, the system mainly does a few things:

Fragment

Divide the original file into smaller subparts.
Salt the subparts.
Store the subparts with encrypted names.
Create a license file which is used to verify if all the subparts belong to the same file and how to arrange them to retrieve the original data.

When the N heroes entered the dungeon with their rings and found a statue with N+1 fingers they were confused and disheartened. Was the prophecy false? did they do something wrong? did they miss some critical side quest? Just then the tall old wizard with a Clausesque beard (all words are made up) remembered the necklace his father gave him when he was a child. The necklace also had a ring in it, how convenient, the prophecy was true after all.
The license here play the role of that last ring, it is just as significant in the process of defragmenting the parts to extract original data.

Defragment

Use the license file to check if all the required parts are present.
Unsalt all the parts.
Sequence the parts and combine them to output the original file.

Salting

Salting is the process of adding something to the subpart which corrupts it or makes it unusable so that if it is not removed, even all the subparts combined wouldn't give the original data back.
For this I wanted a pinch of salt which would be unique for every subpart but still identifiable so that it can be removed while defragmenting.
The user has an option to choose their own salt_length as a parameter while creating an instance of the class, so when a part is salted, a sequence of bytes whose length is the same as salt_length is selected from within the part and copied at a different place in the part itself.
Since the unsalting process is based on the location of the salt rather than the contents, the salt can be modified and the unsalting would work fine as long the location and length are maintained.

To put it in a line,
data = data[:location] + salt + data[location:]

Unsalting

Unsalting is the process of removing the salt from the subpart to make it usable again.
Since the location and length of the salt is known, unsalting is just going to the location and taking away the sequence of bytes that is unnecessary.
data = data[:location]+data[self.salt_length+1:]

Usage, the how?

The usage is quite simple.

1) Make sure the file which needs to be fragmented is in the same directory as the subscrypt.py file.

2) Create an instance of the Subscrypt class divs -> number of subparts

from subscrypt import Subscrypt
sp = Subscrypt() #default divs=4, salt_length=4

from subscrypt import Subscrypt
sp = Subscrypt(divs = 5, salt_length = 6)

3) Use the frag() method to fragment the file into subparts
frag(filename)

from subscrypt import Subscrypt

sp = Subscrypt()

sp.frag("sample.jpg")

frag() will create a directory named after the file name containing the subparts and license file.

4) Use the defrag() method to retrieve the original file from the subparts
defrag(filename, divs, licenseFile)

from subscrypt import Subscrypt

sp = Subscrypt()

sp.defrag("sample.jpg", 4, "license.enc")

defrag() uses the directory created by frag() containing all the subparts and will store the output file in the same directory.

Note:
When initialized, the subscrypt instance looks for two files a_key.key and b_key.key which are important for encryption and decryption in the fragmentation and defragmentation process. If the key files are not found they will be created automatically. If a file was fragmented using a particular set of a_key and b_key, defragmentation will only work with the same a_key and b_key.

A more detailed documentation can be found here.

Use cases, the where?

There are a few cases where something like this could be useful:

Services allowing users to download the content offline but don't want it to be accessible outside of the application.
Situations where privacy is crucial, image data, video data, etc., can be stored this way.
Hiding data in a CTF game in a Hackathon.
Just became the president of a country with nuclear weapons and looking for something more secure than upper case letters and special characters? look further.

Conclusion

This project was just a POC for what I had in mind and can definitely be improvised and built further to maybe become actually useful.

Thanks for reading!