selfTest.cpp

#include "PlantArchitecture.h"
 
#define DOCTEST_CONFIG_IMPLEMENT
#include <doctest.h>
#include "doctest_utils.h"
#include "global.h"
 
using namespace helios;
 
double err_tol = 1e-7;
 
DOCTEST_TEST_CASE("PlantArchitecture Constructor") {
    Context context;
    DOCTEST_CHECK_NOTHROW(PlantArchitecture pa_test(&context));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Cancel Flag") {
    // A cancel flag set before a canopy build must short-circuit the per-plant
    // build loop (no plants built), while the same build with the flag clear
    // builds the full grid. This is the mechanism that lets a long generation be
    // aborted mid-build instead of running to completion.
    auto build = [](bool cancel) -> std::size_t {
        Context context;
        PlantArchitecture pa(&context);
        pa.disableMessages();
        pa.loadPlantModelFromLibrary("bean");
        int flag = cancel ? 1 : 0;
        pa.setCancelFlag(&flag);
        std::vector<uint> ids = pa.buildPlantCanopyFromLibrary(make_vec3(0, 0, 0), make_vec2(0.5f, 0.5f), make_int2(3, 3), 0.f, 1.f);
        return ids.size();
    };
    DOCTEST_CHECK(build(false) == 9);
    DOCTEST_CHECK(build(true) == 0);
 
    // A cancel flag set before advanceTime() must stop the growth loop, leaving
    // the plant far shorter than a full grow.
    auto grow_height = [](bool cancel) -> float {
        Context context;
        PlantArchitecture pa(&context);
        pa.disableMessages();
        pa.loadPlantModelFromLibrary("bean");
        uint pid = pa.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0.f);
        int flag = cancel ? 1 : 0;
        pa.setCancelFlag(&flag);
        pa.advanceTime(40.f);
        return pa.getPlantHeight(pid);
    };
    float full = grow_height(false);
    float cancelled = grow_height(true);
    DOCTEST_CHECK(full > 0.f);
    DOCTEST_CHECK(cancelled < full);
}
 
DOCTEST_TEST_CASE("ShootParameters defineChildShootTypes valid input") {
    ShootParameters sp_test;
    std::vector<std::string> labels = {"typeA", "typeB"};
    std::vector<float> probabilities = {0.4f, 0.6f};
    DOCTEST_CHECK_NOTHROW(sp_test.defineChildShootTypes(labels, probabilities));
}
 
DOCTEST_TEST_CASE("ShootParameters defineChildShootTypes size mismatch") {
    capture_cerr cerr_buffer;
    ShootParameters sp_test;
    std::vector<std::string> labels = {"typeA", "typeB"};
    std::vector<float> probabilities = {0.4f};
    DOCTEST_CHECK_THROWS(sp_test.defineChildShootTypes(labels, probabilities));
}
 
DOCTEST_TEST_CASE("ShootParameters defineChildShootTypes empty vectors") {
    capture_cerr cerr_buffer;
    ShootParameters sp_test;
    std::vector<std::string> labels = {};
    std::vector<float> probabilities = {};
    DOCTEST_CHECK_THROWS(sp_test.defineChildShootTypes(labels, probabilities));
}
 
DOCTEST_TEST_CASE("ShootParameters defineChildShootTypes probabilities sum not equal to 1") {
    capture_cerr cerr_buffer;
    ShootParameters sp_test;
    std::vector<std::string> labels = {"typeA", "typeB"};
    std::vector<float> probabilities = {0.3f, 0.6f}; // Sums to 0.9
    DOCTEST_CHECK_THROWS(sp_test.defineChildShootTypes(labels, probabilities));
}
 
DOCTEST_TEST_CASE("PlantArchitecture defineShootType") {
    Context context;
    PlantArchitecture pa_test(&context);
    ShootParameters sp_define;
    DOCTEST_CHECK_NOTHROW(pa_test.defineShootType("newShootType", sp_define));
}
 
DOCTEST_TEST_CASE("LeafPrototype Constructor") {
    Context context;
    std::minstd_rand0 *generator = context.getRandomGenerator();
    LeafPrototype lp_test(generator);
    DOCTEST_CHECK(lp_test.subdivisions == 1);
    DOCTEST_CHECK(lp_test.unique_prototypes == 1);
    DOCTEST_CHECK(lp_test.leaf_offset.x == doctest::Approx(0.0f).epsilon(err_tol));
    DOCTEST_CHECK(lp_test.leaf_offset.y == doctest::Approx(0.0f).epsilon(err_tol));
    DOCTEST_CHECK(lp_test.leaf_offset.z == doctest::Approx(0.0f).epsilon(err_tol));
}
 
DOCTEST_TEST_CASE("PhytomerParameters Constructor") {
    Context context;
    std::minstd_rand0 *generator = context.getRandomGenerator();
    DOCTEST_CHECK_NOTHROW(PhytomerParameters pp_test(generator));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - almond") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("almond"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - apple") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("apple"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - asparagus") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("asparagus"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - bindweed") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bindweed"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - bean") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Material Naming - bean plant materials have descriptive names") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
 
    // Verify every plant primitive has a descriptive material label (no __auto_ display names)
    std::vector<uint> all_UUIDs = plantarchitecture.getAllPlantUUIDs(plantID);
    DOCTEST_CHECK(all_UUIDs.size() > 0);
    for (uint UUID : all_UUIDs) {
        std::string label = context.getPrimitiveMaterialLabel(UUID);
        DOCTEST_CHECK(label.substr(0, 7) != "__auto_");
    }
 
    // Verify expected material name patterns exist for bean
    std::vector<std::string> materials = context.listMaterials();
    // Note: organs with the same color/texture share a single material, so not every
    // organ type will necessarily have its own material (e.g., petiole and stem may share).
    bool found_trifoliate_leaf = false;
    bool found_unifoliate_leaf = false;
    bool found_stem = false;
    for (const auto &label : materials) {
        if (label.find("bean") != std::string::npos && label.find("trifoliate") != std::string::npos && label.find("leaf") != std::string::npos) {
            found_trifoliate_leaf = true;
        }
        if (label.find("bean") != std::string::npos && label.find("unifoliate") != std::string::npos && label.find("leaf") != std::string::npos) {
            found_unifoliate_leaf = true;
        }
        if (label.find("bean") != std::string::npos && label.find("stem") != std::string::npos) {
            found_stem = true;
        }
    }
    DOCTEST_CHECK(found_trifoliate_leaf);
    DOCTEST_CHECK(found_unifoliate_leaf);
    DOCTEST_CHECK(found_stem);
}
 
DOCTEST_TEST_CASE("Shoot Topology Accessors - getAllShootIDs and getPlantShoot") {
    Context context;
    context.seedRandomGenerator(12345);
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    // getAllShootIDs should return a contiguous, 0-based set of shoot IDs
    std::vector<uint> shootIDs = plantarchitecture.getAllShootIDs(plantID);
    DOCTEST_CHECK(shootIDs.size() > 0);
    for (uint i = 0; i < shootIDs.size(); i++) {
        DOCTEST_CHECK(shootIDs.at(i) == i);
    }
 
    // The base-stem shoot (ID 0) must be rank 0 and have no parent shoot
    const std::shared_ptr<Shoot> &base_shoot = plantarchitecture.getPlantShoot(plantID, 0);
    DOCTEST_CHECK(base_shoot->ID == 0);
    DOCTEST_CHECK(base_shoot->rank == 0);
    DOCTEST_CHECK(base_shoot->parent_shoot_ID == -1);
    DOCTEST_CHECK(!base_shoot->shoot_internode_vertices.empty());
    DOCTEST_CHECK(base_shoot->shoot_internode_vertices.size() == base_shoot->shoot_internode_radii.size());
 
    // A shoot's rank is at least its parent's: a true branch (addChildShoot) is parent rank + 1,
    // while an appended/continuation shoot (appendShoot) keeps the parent's rank. So a child's rank
    // is either equal to or exactly one greater than its parent's.
    for (uint shootID : shootIDs) {
        const std::shared_ptr<Shoot> &shoot = plantarchitecture.getPlantShoot(plantID, shootID);
        if (shoot->parent_shoot_ID >= 0) {
            const std::shared_ptr<Shoot> &parent = plantarchitecture.getPlantShoot(plantID, static_cast<uint>(shoot->parent_shoot_ID));
            DOCTEST_CHECK(shoot->rank >= parent->rank);
            DOCTEST_CHECK(shoot->rank <= parent->rank + 1);
        }
    }
 
    // Out-of-range / invalid IDs must throw rather than return a fallback. Each throwing call
    // is invoked inside a tightly-scoped cerr capture (helios_runtime_error writes to cerr in
    // debug builds before throwing); the resulting bool is asserted only after the capture is
    // destroyed, so doctest failure output is never swallowed.
    auto throws = [&](const std::function<void()> &fn) {
        bool threw = false;
        {
            capture_cerr cerr_buffer;
            try {
                fn();
            } catch (...) {
                threw = true;
            }
        }
        return threw;
    };
    DOCTEST_CHECK(throws([&]() { static_cast<void>(plantarchitecture.getAllShootIDs(plantID + 999)); }));
    DOCTEST_CHECK(throws([&]() { static_cast<void>(plantarchitecture.getPlantShoot(plantID, static_cast<uint>(shootIDs.size()))); }));
    DOCTEST_CHECK(throws([&]() { static_cast<void>(plantarchitecture.getPlantShoot(plantID + 999, 0)); }));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - cheeseweed") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("cheeseweed"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - cowpea") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("cowpea"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - grapevine_VSP") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("grapevine_VSP"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - maize") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("maize"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - olive") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("olive"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - pistachio") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("pistachio"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - puncturevine") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("puncturevine"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - easternredbud") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("easternredbud"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - rice") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("rice"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - butterlettuce") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("butterlettuce"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - sorghum") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("sorghum"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - soybean") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("soybean"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - strawberry") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("strawberry"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - sugarbeet") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("sugarbeet"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - tomato") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("tomato"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - walnut") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("walnut"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("Plant Library Model Building - wheat") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("wheat"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000));
}
 
DOCTEST_TEST_CASE("PlantArchitecture writeTreeQSM") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Build a simple plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 50);
 
    // Test writing TreeQSM format
    std::string filename = "test_plant_qsm.txt";
    DOCTEST_CHECK_NOTHROW(plantarchitecture.writeQSMCylinderFile(plantID, filename));
 
    // Check that file was created and has correct format
    std::ifstream file(filename);
    DOCTEST_CHECK(file.good());
 
    if (file.good()) {
        std::string header_line;
        std::getline(file, header_line);
 
        // Check header contains expected columns
        DOCTEST_CHECK(header_line.find("radius (m)") != std::string::npos);
        DOCTEST_CHECK(header_line.find("length (m)") != std::string::npos);
        DOCTEST_CHECK(header_line.find("start_point") != std::string::npos);
        DOCTEST_CHECK(header_line.find("axis_direction") != std::string::npos);
        DOCTEST_CHECK(header_line.find("branch") != std::string::npos);
        DOCTEST_CHECK(header_line.find("branch_order") != std::string::npos);
 
        // Check that there is at least one data line
        std::string data_line;
        bool has_data = static_cast<bool>(std::getline(file, data_line));
        DOCTEST_CHECK(has_data);
 
        if (has_data) {
            // Count tab-separated values in data line
            size_t tab_count = std::count(data_line.begin(), data_line.end(), '\t');
            DOCTEST_CHECK(tab_count >= 12); // Should have at least 13 columns (12 tabs)
        }
 
        file.close();
 
        // Clean up test file
        std::remove(filename.c_str());
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture writeTreeQSM invalid plant") {
    capture_cerr cerr_buffer;
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test with invalid plant ID
    DOCTEST_CHECK_THROWS(plantarchitecture.writeQSMCylinderFile(999, "invalid_plant.txt"));
}
 
DOCTEST_TEST_CASE("PlantArchitecture pruneSolidBoundaryCollisions") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable collision detection first
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Load a plant model from library
    plantarchitecture.loadPlantModelFromLibrary("tomato");
 
    // Create a plant and let it grow first WITHOUT boundaries
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 15); // Substantial growth to ensure objects exist
 
    // Get object count after growth but before boundaries
    std::vector<uint> objects_before_boundaries = plantarchitecture.getAllObjectIDs();
    uint count_before_boundaries = objects_before_boundaries.size();
 
    // Ensure we have some objects to work with
    DOCTEST_CHECK(count_before_boundaries > 0);
 
    // Now create solid boundaries that will definitely intersect with plant parts
    // Place boundaries at z=0.05 to intersect with low-lying plant parts
    std::vector<uint> boundary_UUIDs;
    for (int i = -2; i <= 2; i++) {
        for (int j = -2; j <= 2; j++) {
            // Create a grid of triangles to ensure we catch plant parts
            boundary_UUIDs.push_back(context.addTriangle(make_vec3(i * 0.1f, j * 0.1f, 0.05f), make_vec3((i + 1) * 0.1f, j * 0.1f, 0.05f), make_vec3(i * 0.1f, (j + 1) * 0.1f, 0.05f)));
        }
    }
 
    // Enable solid obstacle avoidance with the boundaries
    plantarchitecture.enableSolidObstacleAvoidance(boundary_UUIDs, 0.2f);
 
    // Trigger another growth step which should call pruneSolidBoundaryCollisions()
    // Use a very small time step to minimize new growth
    plantarchitecture.advanceTime(plantID, 0.1f); // Very small step to trigger pruning
 
    // Get final object count
    std::vector<uint> final_objects = plantarchitecture.getAllObjectIDs();
    uint final_count = final_objects.size();
 
    // Verify that objects were actually pruned by checking that we have fewer objects
    // than we would expect if no pruning occurred. Since some growth may still happen,
    // we check if the final count is reasonable given pruning occurred.
    // The key test is that our implementation ran without errors and produced output
    // indicating pruning occurred (visible in test output: "Pruned X objects").
    DOCTEST_CHECK(final_count > 0); // Basic sanity check - we should still have some objects
}
 
DOCTEST_TEST_CASE("PlantArchitecture pruneSolidBoundaryCollisions no boundaries") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Load a plant model from library
    plantarchitecture.loadPlantModelFromLibrary("tomato");
 
    // Create a simple plant
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5);
 
    // Get initial object count
    std::vector<uint> initial_objects = plantarchitecture.getAllObjectIDs();
    uint initial_count = initial_objects.size();
 
    // Advance time again without boundaries - should not prune anything
    plantarchitecture.advanceTime(plantID, 2);
 
    // Check that no objects were pruned (may have grown more)
    std::vector<uint> final_objects = plantarchitecture.getAllObjectIDs();
    uint final_count = final_objects.size();
 
    DOCTEST_CHECK(final_count >= initial_count);
}
 
DOCTEST_TEST_CASE("PlantArchitecture advanceTime after pruneBranch leaves empty shoot shell") {
    // Pruning a branch at node 0 deletes all of its phytomers and its internode tube object, but
    // leaves the (now empty) Shoot in the shoot_tree and a stale entry in the parent's childIDs.
    // advanceTime must tolerate these empty shells: the per-shoot volume bookkeeping loop and the
    // recursive Shoot::updateShootNodes both used to dereference the cleared geometry / write to the
    // deleted tube object and crash. This reproduces the user-reported crash.
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("apple");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 365);
 
    // Find a child shoot of the trunk (shoot 0) that still has phytomers, then prune it from node 0.
    const std::shared_ptr<Shoot> trunk = plantarchitecture.getPlantShoot(plantID, 0);
    int branchID = -1;
    for (const auto &[node_index, shootIDs]: trunk->childIDs) {
        for (const int shootID: shootIDs) {
            if (!plantarchitecture.getPlantShoot(plantID, shootID)->phytomers.empty()) {
                branchID = shootID;
                break;
            }
        }
        if (branchID >= 0) {
            break;
        }
    }
    DOCTEST_REQUIRE(branchID >= 0);
 
    DOCTEST_CHECK_NOTHROW(plantarchitecture.pruneBranch(plantID, (uint) branchID, 0));
    DOCTEST_CHECK(plantarchitecture.getPlantShoot(plantID, (uint) branchID)->phytomers.empty());
 
    // getShootInternodeObjectIDs must not return the dangling tube object ID of the pruned shell.
    std::vector<uint> internode_objIDs = plantarchitecture.getShootInternodeObjectIDs(plantID);
    for (uint objID: internode_objIDs) {
        DOCTEST_CHECK(context.doesObjectExist(objID));
    }
 
    // The crash occurred here, inside advanceTime, while iterating over the empty pruned shoot.
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 365));
}
 
DOCTEST_TEST_CASE("PlantArchitecture hard collision avoidance base stem protection") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable collision detection first
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Load a plant model from library
    plantarchitecture.loadPlantModelFromLibrary("tomato");
 
    // Create a plant that starts slightly below ground surface (e.g., at z = -0.05)
    // This simulates the common scenario where ground model is slightly uneven
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, -0.05f), 0);
 
    // Create ground surface as solid obstacle slightly above plant base
    std::vector<uint> ground_UUIDs;
 
    // Create a ground patch that the plant would intersect if it doesn't grow upward
    for (int i = -2; i <= 2; i++) {
        for (int j = -2; j <= 2; j++) {
            ground_UUIDs.push_back(context.addTriangle(make_vec3(i * 0.2f, j * 0.2f, 0.0f), // Ground at z=0
                                                       make_vec3((i + 1) * 0.2f, j * 0.2f, 0.0f), make_vec3(i * 0.2f, (j + 1) * 0.2f, 0.0f)));
            ground_UUIDs.push_back(context.addTriangle(make_vec3((i + 1) * 0.2f, (j + 1) * 0.2f, 0.0f), make_vec3((i + 1) * 0.2f, j * 0.2f, 0.0f), make_vec3(i * 0.2f, (j + 1) * 0.2f, 0.0f)));
        }
    }
 
    // Enable hard solid obstacle avoidance with the ground
    plantarchitecture.enableSolidObstacleAvoidance(ground_UUIDs, 0.3f);
 
    // Let the plant grow - it should grow upward despite starting below ground
    // The first 3 nodes of the base stem should ignore solid obstacles
    plantarchitecture.advanceTime(plantID, 10); // Sufficient growth time
 
    // Get all plant objects to analyze growth direction
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate center of mass of all plant objects to verify upward growth
    // If the plant made a U-turn downward, the center would be below the starting position
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            // Get object center using bounding box
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
 
            vec3 object_center = (min_corner + max_corner) / 2.0f;
 
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // The center of mass should be above the starting position (z = -0.05)
        // This verifies the plant grew upward rather than making a U-turn downward
        DOCTEST_CHECK(center_of_mass.z > -0.075f);
 
        // The key test is that the plant didn't curve significantly downward (U-turn behavior)
        // A U-turn would result in center of mass well below starting position (e.g., < -0.06)
        // Any value above -0.045 indicates successful avoidance of U-turn behavior
        DOCTEST_CHECK(center_of_mass.z > -0.075f); // Should not have made a U-turn downward
    }
 
    // Additional check: the plant should still exist (wasn't completely pruned)
    // and should have a reasonable number of objects
    DOCTEST_CHECK(plant_objects.size() >= 5); // Should have internodes, leaves, etc.
}
 
DOCTEST_TEST_CASE("PlantArchitecture enableSolidObstacleAvoidance fruit adjustment control") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Create some obstacles
    std::vector<uint> obstacle_UUIDs;
    obstacle_UUIDs.push_back(context.addTriangle(make_vec3(-1, -1, 0), make_vec3(1, -1, 0), make_vec3(-1, 1, 0)));
    obstacle_UUIDs.push_back(context.addTriangle(make_vec3(1, 1, 0), make_vec3(1, -1, 0), make_vec3(-1, 1, 0)));
 
    // Test enabling solid obstacle avoidance with fruit adjustment enabled (default)
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.5f));
 
    // Test enabling solid obstacle avoidance with fruit adjustment explicitly enabled
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.5f, true));
 
    // Test enabling solid obstacle avoidance with fruit adjustment disabled
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.5f, false));
 
    // Test with different avoidance distance and disabled fruit adjustment
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.3f, false));
}
 
DOCTEST_TEST_CASE("PlantArchitecture base stem protection with short internodes") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable collision detection first
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Load a plant model
    plantarchitecture.loadPlantModelFromLibrary("tomato");
 
    // Create a plant that starts at ground level
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Let it grow a small amount first to create some short internodes
    plantarchitecture.advanceTime(plantID, 2);
 
    // Create ground surface as solid obstacle
    std::vector<uint> ground_UUIDs;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            ground_UUIDs.push_back(context.addTriangle(make_vec3(i * 0.3f, j * 0.3f, -0.01f), // Ground slightly below
                                                       make_vec3((i + 1) * 0.3f, j * 0.3f, -0.01f), make_vec3(i * 0.3f, (j + 1) * 0.3f, -0.01f)));
            ground_UUIDs.push_back(context.addTriangle(make_vec3((i + 1) * 0.3f, (j + 1) * 0.3f, -0.01f), make_vec3((i + 1) * 0.3f, j * 0.3f, -0.01f), make_vec3(i * 0.3f, (j + 1) * 0.3f, -0.01f)));
        }
    }
 
    // Enable solid obstacle avoidance with the ground
    plantarchitecture.enableSolidObstacleAvoidance(ground_UUIDs, 0.2f);
 
    // Let the plant grow more - it should grow normally despite having short internodes
    // The length-based protection should kick in even if node count > 3
    plantarchitecture.advanceTime(plantID, 8);
 
    // Get all plant objects to verify plant survived and grew upward
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate center of mass to verify upward growth
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // The plant should have grown upward (center above ground level)
        DOCTEST_CHECK(center_of_mass.z > 0.01f);
 
        // Plant should have grown to a reasonable height, indicating protection worked
        // Since we're testing short internodes, the height will be more modest
        DOCTEST_CHECK(center_of_mass.z > 0.05f);
    }
 
    // Plant should have grown successfully (not been completely pruned)
    DOCTEST_CHECK(plant_objects.size() >= 10);
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points Basic Functionality") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable collision detection for this test (optional - attraction points work independently)
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Test basic attraction points functionality
    std::vector<vec3> attraction_points = {make_vec3(1.0f, 0.0f, 1.0f), make_vec3(0.0f, 1.0f, 1.5f)};
 
    // Enable attraction points with valid parameters
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(attraction_points, 60.0f, 0.15f, 0.7f));
 
    // Test parameter validation - invalid angle
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(0.0f, 0.1f, 0.5f));
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(190.0f, 0.1f, 0.5f));
 
    // Test parameter validation - invalid distance
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(80.0f, 0.0f, 0.5f));
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(80.0f, -0.1f, 0.5f));
 
    // Test parameter validation - invalid weight
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(80.0f, 0.1f, -0.1f));
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(80.0f, 0.1f, 1.1f));
 
    // Update attraction points
    std::vector<vec3> new_attraction_points = {make_vec3(2.0f, 0.0f, 2.0f)};
    DOCTEST_CHECK_NOTHROW(plantarchitecture.updateAttractionPoints(new_attraction_points));
 
    // Disable attraction points
    DOCTEST_CHECK_NOTHROW(plantarchitecture.disableAttractionPoints());
 
    // Test error when trying to update disabled attraction points
    DOCTEST_CHECK_THROWS(plantarchitecture.updateAttractionPoints(new_attraction_points));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points Independent of Collision Detection") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    std::vector<vec3> attraction_points = {make_vec3(1.0f, 0.0f, 1.0f)};
 
    // Attraction points should work without collision detection enabled
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(attraction_points));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points Empty Vector") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    std::vector<vec3> empty_attraction_points;
 
    // Try to enable attraction points with empty vector
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(empty_attraction_points));
 
    // Enable with valid points first (should work without collision detection)
    std::vector<vec3> valid_points = {make_vec3(1.0f, 0.0f, 1.0f)};
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(valid_points));
 
    // Try to update with empty vector (should fail)
    DOCTEST_CHECK_THROWS(plantarchitecture.updateAttractionPoints(empty_attraction_points));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Native Attraction Point Cone Detection") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Set up attraction points at known locations
    std::vector<vec3> attraction_points = {
            make_vec3(0.0f, 0.0f, 2.0f), // Directly ahead
            make_vec3(1.0f, 0.0f, 1.0f), // Right and forward
            make_vec3(-1.0f, 0.0f, 1.0f), // Left and forward
            make_vec3(0.0f, 2.0f, 0.0f), // Far to the side (should be outside cone)
    };
 
    // Enable attraction points (should work without collision detection)
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(attraction_points, 60.0f, 3.0f, 0.7f));
 
    // Test 1: Looking straight up should find the point directly ahead
    vec3 vertex = make_vec3(0.0f, 0.0f, 0.0f);
    vec3 look_direction = make_vec3(0.0f, 0.0f, 1.0f); // Looking up
    vec3 direction_to_closest;
 
    bool found = plantarchitecture.detectAttractionPointsInCone(vertex, look_direction, 3.0f, 60.0f, direction_to_closest);
    DOCTEST_CHECK(found);
 
    // The closest should be the one directly ahead (0,0,2)
    vec3 expected_direction = make_vec3(0.0f, 0.0f, 1.0f);
    float dot_product = direction_to_closest * expected_direction;
    DOCTEST_CHECK(dot_product > 0.99f); // Should be very close to parallel
 
    // Test 2: Looking to the side should NOT find the point far to the side (outside cone)
    look_direction = make_vec3(1.0f, 0.0f, 0.0f); // Looking right
    found = plantarchitecture.detectAttractionPointsInCone(vertex, look_direction, 3.0f, 30.0f, direction_to_closest);
 
    // With a narrow cone (30 degrees), the side point at (0,2,0) should be outside the cone
    // But the point at (1,0,1) might be visible, so we might still find something
 
    // Test 3: Test parameter validation
    found = plantarchitecture.detectAttractionPointsInCone(vertex, look_direction, -1.0f, 60.0f, direction_to_closest);
    DOCTEST_CHECK(!found); // Should fail with negative look ahead distance
 
    found = plantarchitecture.detectAttractionPointsInCone(vertex, look_direction, 3.0f, 0.0f, direction_to_closest);
    DOCTEST_CHECK(!found); // Should fail with zero half angle
 
    found = plantarchitecture.detectAttractionPointsInCone(vertex, look_direction, 3.0f, 180.0f, direction_to_closest);
    DOCTEST_CHECK(!found); // Should fail with 180 degree half angle
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points Plant Growth Integration") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable collision detection first
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Set up attraction points above the plant to guide upward growth
    std::vector<vec3> attraction_points = {
            make_vec3(0.1f, 0.1f, 1.0f), // Close to plant base but higher
            make_vec3(0.0f, 0.0f, 1.5f) // Further away and higher
    };
 
    // Enable attraction points with moderate attraction weight
    plantarchitecture.enableAttractionPoints(attraction_points, 80.0f, 0.2f, 0.6f);
 
    // Create a simple plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Let the plant grow with attraction points enabled
    plantarchitecture.advanceTime(plantID, 5);
 
    // Get plant geometry to verify growth occurred
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate plant center of mass to verify upward growth toward attraction points
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // Plant should have grown upward toward attraction points
        // Bean plants start small, so adjust expectations to realistic growth
        DOCTEST_CHECK(center_of_mass.z > 0.01f); // At least 1cm above ground
 
        // Plant should show some lateral movement toward attraction points
        // (not perfectly vertical growth due to attraction)
        float lateral_distance = sqrt(center_of_mass.x * center_of_mass.x + center_of_mass.y * center_of_mass.y);
        DOCTEST_CHECK(lateral_distance >= 0.0f); // Basic sanity check
    }
 
    // Test disabling attraction points mid-growth
    plantarchitecture.disableAttractionPoints();
 
    // Continue growing - should revert to natural growth patterns
    plantarchitecture.advanceTime(plantID, 3);
 
    // Verify plant continues to exist and grow
    std::vector<uint> final_plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(final_plant_objects.size() >= plant_objects.size());
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points Priority Over Collision Avoidance") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Create some obstacle geometry
    std::vector<uint> obstacle_UUIDs;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            obstacle_UUIDs.push_back(
                    context.addTriangle(make_vec3(i * 0.3f + 0.5f, j * 0.3f + 0.5f, 0.5f + i * 0.1f), make_vec3((i + 1) * 0.3f + 0.5f, (j + 1) * 0.3f + 0.5f, 0.5f + i * 0.1f), make_vec3((i + 1) * 0.3f + 0.5f, j * 0.3f + 0.5f, 0.5f + i * 0.1f)));
        }
    }
 
    // Enable collision detection with obstacles
    plantarchitecture.enableSoftCollisionAvoidance(obstacle_UUIDs);
 
    // Set up attraction points on the opposite side of obstacles
    std::vector<vec3> attraction_points = {
            make_vec3(-0.5f, 0.0f, 1.0f) // Away from obstacles
    };
 
    // Enable attraction points - should override soft collision avoidance
    plantarchitecture.enableAttractionPoints(attraction_points, 90.0f, 0.3f, 0.8f);
 
    // Create a plant near obstacles
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0.3f, 0.3f, 0), 0);
 
    // Let the plant grow - should be attracted away from obstacles
    plantarchitecture.advanceTime(plantID, 4);
 
    // Verify plant grew successfully (attraction points should guide it away from obstacles)
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Check that plant moved toward attraction point (negative x direction)
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // Plant should have grown upward
        DOCTEST_CHECK(center_of_mass.z > 0.01f); // At least 1cm above ground
 
        // With strong attraction weight (0.8), plant should show movement toward attraction point
        // This validates that attraction points override soft collision avoidance
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture Hard Obstacle Avoidance Takes Priority Over Attraction Points") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Create ground-level obstacles that would trigger hard obstacle avoidance
    std::vector<uint> solid_obstacle_UUIDs;
    for (int i = -1; i <= 1; i++) {
        for (int j = -1; j <= 1; j++) {
            solid_obstacle_UUIDs.push_back(context.addTriangle(make_vec3(i * 0.1f, j * 0.1f, 0.1f), make_vec3((i + 1) * 0.1f, (j + 1) * 0.1f, 0.1f), make_vec3((i + 1) * 0.1f, j * 0.1f, 0.1f)));
        }
    }
 
    // Enable collision detection first
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Enable solid obstacle avoidance (hard obstacles)
    plantarchitecture.enableSolidObstacleAvoidance(solid_obstacle_UUIDs, 0.15f);
 
    // Set up attraction points in the opposite direction of safe growth
    std::vector<vec3> attraction_points = {
            make_vec3(0.0f, 0.0f, 0.05f) // Low attraction point that would conflict with obstacle avoidance
    };
 
    // Enable attraction points
    plantarchitecture.enableAttractionPoints(attraction_points, 70.0f, 0.1f, 0.9f);
 
    // Create a plant at the origin
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Let the plant grow - hard obstacle avoidance should take priority
    plantarchitecture.advanceTime(plantID, 3);
 
    // Verify plant grew successfully despite conflicting guidance
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Plant should have grown upward to avoid hard obstacles, regardless of attraction points
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // Hard obstacle avoidance should force upward growth
        DOCTEST_CHECK(center_of_mass.z > 0.01f); // At least 1cm above ground
 
        // Plant should have avoided the low obstacles (which are at 0.1m height)
        // So plant should be higher than the obstacle level
        DOCTEST_CHECK(center_of_mass.z > 0.005f); // Above the base obstacle level
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture Attraction Points with Surface Following") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Create a vertical wall that we want the plant to approach and then grow parallel to
    std::vector<uint> wall_obstacle_UUIDs;
    std::vector<vec3> wall_attraction_points;
 
    // Create vertical wall at x = 0.3
    for (int i = 0; i < 5; i++) {
        for (int j = 0; j < 3; j++) {
            // Wall surface obstacles (solid)
            wall_obstacle_UUIDs.push_back(context.addTriangle(make_vec3(0.3f, i * 0.05f, j * 0.05f), make_vec3(0.3f, (i + 1) * 0.05f, (j + 1) * 0.05f), make_vec3(0.3f, (i + 1) * 0.05f, j * 0.05f)));
 
            // Attraction points on the wall surface
            wall_attraction_points.push_back(make_vec3(0.29f, i * 0.05f + 0.025f, j * 0.05f + 0.025f));
        }
    }
 
    // Enable collision detection with wall obstacles
    plantarchitecture.enableSoftCollisionAvoidance();
 
    // Enable solid obstacle avoidance for the wall
    plantarchitecture.enableSolidObstacleAvoidance(wall_obstacle_UUIDs, 0.05f);
 
    // Enable attraction points on the wall surface with reduced obstacle reduction factor
    // This allows the plant to maintain some attraction even when avoiding obstacles
    plantarchitecture.enableAttractionPoints(wall_attraction_points, 60.0f, 0.1f, 0.8f);
    plantarchitecture.setAttractionParameters(60.0f, 0.1f, 0.8f, 0.5f); // Higher obstacle reduction factor
 
    // Create a plant at origin that should grow toward the wall
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Let the plant grow - it should approach the wall and then follow it
    plantarchitecture.advanceTime(plantID, 4);
 
    // Get plant geometry to verify behavior
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate plant center of mass
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // Plant should have grown upward
        DOCTEST_CHECK(center_of_mass.z > 0.01f);
 
        // The key test is that the plant grows successfully with both attraction points and obstacle avoidance enabled
        // This validates that the new blended approach doesn't cause conflicts or crashes
        // The exact movement direction depends on many factors, but the plant should grow
 
        // This test primarily validates that our improved blending logic works without errors
        // when both attraction points and hard obstacle avoidance are enabled simultaneously
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture Smooth Hard Obstacle Avoidance") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableSoftCollisionAvoidance();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    // Create obstacles at varying distances to test smooth avoidance behavior
    std::vector<uint> obstacle_UUIDs;
 
    // Create obstacles at different normalized distances from plant growth path
    // Plant will grow upward from (0,0,0), so place obstacles to the side at different z heights
    for (int i = 0; i < 4; i++) {
        float z_height = 0.1f + i * 0.05f; // Heights: 0.1, 0.15, 0.2, 0.25
 
        // Create obstacle patches at different distances from expected growth path
        float x_distance = 0.05f + i * 0.02f; // Distances: 0.05, 0.07, 0.09, 0.11
 
        obstacle_UUIDs.push_back(context.addTriangle(make_vec3(x_distance, -0.02f, z_height), make_vec3(x_distance + 0.04f, -0.02f, z_height), make_vec3(x_distance, 0.02f, z_height)));
        obstacle_UUIDs.push_back(context.addTriangle(make_vec3(x_distance + 0.04f, 0.02f, z_height), make_vec3(x_distance + 0.04f, -0.02f, z_height), make_vec3(x_distance, 0.02f, z_height)));
    }
 
    plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.25f);
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 8);
 
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate plant center of mass to verify it avoided obstacles
    vec3 center_of_mass = make_vec3(0, 0, 0);
    uint total_objects = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            center_of_mass = center_of_mass + object_center;
            total_objects++;
        }
    }
 
    if (total_objects > 0) {
        center_of_mass = center_of_mass / float(total_objects);
 
        // Plant should have grown upward successfully
        DOCTEST_CHECK(center_of_mass.z > 0.01f);
 
        // Plant should have moved away from obstacles (toward negative x since obstacles are on positive x side)
        // This tests that smooth avoidance works without the harsh discrete jumps
        DOCTEST_CHECK(center_of_mass.x <= 0.01f); // Should stay near or move away from obstacles
 
        // Key validation: plant grows successfully with smooth obstacle avoidance
        // The smooth distance-normalized approach should provide gradual, natural avoidance
        // rather than abrupt discrete changes in behavior
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture Hard Obstacle Avoidance Buffer Zone") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableSoftCollisionAvoidance();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    // Create a vertical post obstacle similar to the test case image
    std::vector<uint> post_UUIDs;
    float post_radius = 0.02f; // 2cm radius post
    float post_height = 0.5f; // 50cm tall post
 
    // Create post as a series of triangles forming a cylinder at x=0.1m (10cm from plant center)
    int segments = 8;
    for (int i = 0; i < segments; i++) {
        float theta1 = 2.0f * M_PI * float(i) / float(segments);
        float theta2 = 2.0f * M_PI * float(i + 1) / float(segments);
 
        vec3 p1_bottom = make_vec3(0.1f + post_radius * cos(theta1), post_radius * sin(theta1), 0);
        vec3 p2_bottom = make_vec3(0.1f + post_radius * cos(theta2), post_radius * sin(theta2), 0);
        vec3 p1_top = make_vec3(0.1f + post_radius * cos(theta1), post_radius * sin(theta1), post_height);
        vec3 p2_top = make_vec3(0.1f + post_radius * cos(theta2), post_radius * sin(theta2), post_height);
 
        // Two triangles per segment to form cylinder walls
        post_UUIDs.push_back(context.addTriangle(p1_bottom, p2_bottom, p1_top));
        post_UUIDs.push_back(context.addTriangle(p2_bottom, p2_top, p1_top));
    }
 
    // Set detection distance and enable solid obstacle avoidance
    float detection_distance = 0.2f; // 20cm detection distance
    float expected_buffer = detection_distance * 0.05f; // 5% buffer = 1cm
 
    plantarchitecture.enableSolidObstacleAvoidance(post_UUIDs, detection_distance);
 
    // Create plant at origin, should grow toward +x direction but avoid the post
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 8);
 
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate minimum distance between plant and post to verify buffer is maintained
    float min_distance_to_post = std::numeric_limits<float>::max();
    vec3 post_center = make_vec3(0.1f, 0, 0.25f); // Center of post
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
 
            // Check distance from each corner of plant object to post center
            vec3 corners[8] = {make_vec3(min_corner.x, min_corner.y, min_corner.z), make_vec3(max_corner.x, min_corner.y, min_corner.z), make_vec3(min_corner.x, max_corner.y, min_corner.z), make_vec3(min_corner.x, min_corner.y, max_corner.z),
                               make_vec3(max_corner.x, max_corner.y, min_corner.z), make_vec3(max_corner.x, min_corner.y, max_corner.z), make_vec3(min_corner.x, max_corner.y, max_corner.z), make_vec3(max_corner.x, max_corner.y, max_corner.z)};
 
            for (int i = 0; i < 8; i++) {
                float distance = (corners[i] - post_center).magnitude();
                min_distance_to_post = std::min(min_distance_to_post, distance);
            }
        }
    }
 
    // Plant should maintain buffer distance from post (accounting for post radius)
    float expected_min_distance = post_radius + expected_buffer;
    DOCTEST_CHECK(min_distance_to_post >= expected_min_distance * 0.8f); // Allow 20% tolerance for growth dynamics
 
    // Plant should have grown upward successfully despite obstacle
    vec3 plant_center = make_vec3(0, 0, 0);
    uint plant_object_count = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            plant_center = plant_center + object_center;
            plant_object_count++;
        }
    }
 
    if (plant_object_count > 0) {
        plant_center = plant_center / float(plant_object_count);
        DOCTEST_CHECK(plant_center.z > 0.01f); // Should grow upward
 
        // Plant should avoid growing directly into the post (should stay away from x=0.1)
        // With buffer zone avoidance, plant should either go around or grow upward
        DOCTEST_CHECK(fabs(plant_center.x - 0.1f) > expected_buffer * 0.5f); // Should maintain some distance from post center line
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture solid obstacle avoidance works independently") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Create obstacle geometry (ground plane)
    std::vector<uint> obstacle_UUIDs;
    obstacle_UUIDs.push_back(context.addTriangle(make_vec3(-1, -1, -0.01f), make_vec3(1, -1, -0.01f), make_vec3(-1, 1, -0.01f)));
    obstacle_UUIDs.push_back(context.addTriangle(make_vec3(1, 1, -0.01f), make_vec3(1, -1, -0.01f), make_vec3(-1, 1, -0.01f)));
 
    // Test: Enable ONLY solid obstacle avoidance (no soft collision avoidance)
    // This should work independently after our fix
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSolidObstacleAvoidance(obstacle_UUIDs, 0.2f));
 
    // Load and build a plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Advance time - this should work without crashing and plant should grow upward
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 5.0f));
 
    // Verify plant was created and grew
    std::vector<uint> plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Calculate plant center of mass to verify upward growth (avoiding ground obstacle)
    vec3 plant_center = make_vec3(0, 0, 0);
    uint plant_object_count = 0;
 
    for (uint objID: plant_objects) {
        if (context.doesObjectExist(objID)) {
            vec3 min_corner, max_corner;
            context.getObjectBoundingBox(objID, min_corner, max_corner);
            vec3 object_center = (min_corner + max_corner) / 2.0f;
            plant_center = plant_center + object_center;
            plant_object_count++;
        }
    }
 
    if (plant_object_count > 0) {
        plant_center = plant_center / float(plant_object_count);
        // Plant should grow upward, avoiding the ground obstacle at z = -0.01f
        DOCTEST_CHECK(plant_center.z > 0.01f);
    }
 
    // Test: Add soft collision avoidance on top of existing solid obstacle avoidance
    // This should work together seamlessly
    std::vector<uint> soft_target_UUIDs;
    std::vector<uint> soft_target_IDs;
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableSoftCollisionAvoidance(soft_target_UUIDs, soft_target_IDs));
 
    // Continue growing - should still work with both systems enabled
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 2.0f));
 
    // Verify plant continued to grow
    std::vector<uint> final_plant_objects = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(final_plant_objects.size() >= plant_objects.size());
}
 
DOCTEST_TEST_CASE("PlantArchitecture Per-Plant Attraction Points") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Disable messages for cleaner test output
    plantarchitecture.disableMessages();
 
    // Create two plants at different positions
    uint plantID1 = plantarchitecture.addPlantInstance(make_vec3(0, 0, 0), 0);
    uint plantID2 = plantarchitecture.addPlantInstance(make_vec3(5, 0, 0), 0);
 
    // Set different attraction points for each plant
    std::vector<vec3> attraction_points_1 = {make_vec3(1.0f, 0.0f, 1.0f), make_vec3(0.0f, 1.0f, 1.5f)};
    std::vector<vec3> attraction_points_2 = {make_vec3(6.0f, 0.0f, 1.0f), make_vec3(5.0f, 1.0f, 1.5f)};
 
    // Enable attraction points for each plant with different parameters
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(plantID1, attraction_points_1, 60.0f, 0.2f, 0.7f));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(plantID2, attraction_points_2, 45.0f, 0.15f, 0.5f));
 
    // Test parameter updates for individual plants
    DOCTEST_CHECK_NOTHROW(plantarchitecture.setAttractionParameters(plantID1, 80.0f, 0.25f, 0.8f, 0.6f));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.updateAttractionPoints(plantID2, {make_vec3(6.5f, 0.5f, 2.0f)}));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.appendAttractionPoints(plantID1, {make_vec3(1.5f, 1.5f, 2.0f)}));
 
    // Test disabling for individual plants
    DOCTEST_CHECK_NOTHROW(plantarchitecture.disableAttractionPoints(plantID1));
 
    // Test error handling for invalid plant IDs
    DOCTEST_CHECK_THROWS(plantarchitecture.enableAttractionPoints(9999, attraction_points_1));
    DOCTEST_CHECK_THROWS(plantarchitecture.disableAttractionPoints(9999));
    DOCTEST_CHECK_THROWS(plantarchitecture.updateAttractionPoints(9999, attraction_points_1));
    DOCTEST_CHECK_THROWS(plantarchitecture.appendAttractionPoints(9999, attraction_points_1));
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(9999, 60.0f, 0.15f, 0.7f, 0.75f));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Global vs Per-Plant Interaction") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Disable messages for cleaner test output
    plantarchitecture.disableMessages();
 
    // Create a plant first
    uint plantID1 = plantarchitecture.addPlantInstance(make_vec3(0, 0, 0), 0);
 
    // Set global attraction points - should affect all plants including existing ones
    std::vector<vec3> global_attraction_points = {make_vec3(1.0f, 0.0f, 1.0f), make_vec3(0.0f, 1.0f, 1.5f)};
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(global_attraction_points, 60.0f, 0.15f, 0.7f));
 
    // Create another plant after global attraction points are set
    uint plantID2 = plantarchitecture.addPlantInstance(make_vec3(5, 0, 0), 0);
 
    // Now set plant-specific attraction points for plant 1 - should override global for that plant
    std::vector<vec3> specific_attraction_points = {make_vec3(2.0f, 0.0f, 2.0f)};
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(plantID1, specific_attraction_points, 45.0f, 0.1f, 0.5f));
 
    // Test that global update affects all plants with attraction points enabled
    DOCTEST_CHECK_NOTHROW(plantarchitecture.updateAttractionPoints({make_vec3(3.0f, 0.0f, 3.0f)}));
 
    // Global disable should affect all plants
    DOCTEST_CHECK_NOTHROW(plantarchitecture.disableAttractionPoints());
 
    // Re-enable global attraction points to test backward compatibility
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(global_attraction_points));
}
 
DOCTEST_TEST_CASE("PlantArchitecture Plant-Specific Attraction Points Validation") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Disable messages for cleaner test output
    plantarchitecture.disableMessages();
 
    // Create plants to test validation and method calls
    uint plantID1 = plantarchitecture.addPlantInstance(make_vec3(0, 0, 0), 0);
    uint plantID2 = plantarchitecture.addPlantInstance(make_vec3(5, 0, 0), 0);
 
    // Set different attraction points for each plant
    std::vector<vec3> attraction_points_1 = {make_vec3(1.0f, 0.0f, 1.0f)};
    std::vector<vec3> attraction_points_2 = {make_vec3(6.0f, 0.0f, 1.0f)};
 
    // Test that plant-specific methods work correctly
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(plantID1, attraction_points_1));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.enableAttractionPoints(plantID2, attraction_points_2));
 
    // Test parameter validation
    DOCTEST_CHECK_THROWS(plantarchitecture.enableAttractionPoints(plantID1, {}, 60.0f, 0.15f, 0.7f)); // Empty vector
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(plantID1, 0.0f, 0.15f, 0.7f)); // Invalid angle
    DOCTEST_CHECK_THROWS(plantarchitecture.setAttractionParameters(plantID1, 60.0f, 0.0f, 0.7f)); // Invalid distance
 
    // Test successful parameter updates
    DOCTEST_CHECK_NOTHROW(plantarchitecture.setAttractionParameters(plantID1, 80.0f, 0.25f, 0.8f, 0.6f));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.updateAttractionPoints(plantID2, {make_vec3(6.5f, 0.5f, 2.0f)}));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.appendAttractionPoints(plantID1, {make_vec3(1.5f, 1.5f, 2.0f)}));
 
    // Test disabling
    DOCTEST_CHECK_NOTHROW(plantarchitecture.disableAttractionPoints(plantID1));
}
 
DOCTEST_TEST_CASE("PlantArchitecture removeShootFloralBuds") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test invalid plant ID - should throw
    capture_cerr cerr_buffer;
    DOCTEST_CHECK_THROWS(plantarchitecture.removeShootFloralBuds(9999, 0));
 
    // Create a plant instance to test valid plant ID but invalid shoot ID
    uint plantID = plantarchitecture.addPlantInstance(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != -1);
 
    // Test invalid shoot ID - should throw
    DOCTEST_CHECK_THROWS(plantarchitecture.removeShootFloralBuds(plantID, 9999));
}
 
DOCTEST_TEST_CASE("PlantArchitecture XML write with flowers and fruit") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Load tomato model (has flowers and fruit)
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("tomato"));
 
    // Build simple plant
    vec3 base_position(1.0f, 2.0f, 0.5f);
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(base_position, 180);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Write plant structure to XML (should not crash even if no flowers)
    std::string xml_filename = "test_plant_xml_write.xml";
    DOCTEST_CHECK_NOTHROW(plantarchitecture.writePlantStructureXML(plantID, xml_filename));
 
    // Clean up test file
    std::remove(xml_filename.c_str());
}
 
DOCTEST_TEST_CASE("PlantArchitecture child shoot rotation with multiple petioles per internode") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Regression test for bug where child shoots from different petioles had the same rotation
    // The fix changed line 4778 in PlantArchitecture.cpp to use petioles_per_internode
    // instead of axillary_vegetative_buds.size() for calculating rotation offset
 
    // Use bean plant which has 2 petioles per internode in the unifoliate stage
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Advance time to allow growth and child shoot formation
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 10.0f));
 
    // Verify plant created geometry (basic sanity check that build succeeded)
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
 
    // If this test passes, the fix is working (plant builds without errors)
    // The actual visual verification of proper 180-degree offset would require
    // more complex geometric analysis that is beyond the scope of a unit test
}
 
DOCTEST_TEST_CASE("PlantArchitecture plant_name optional object data") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable plant_name optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("plant_name"));
 
    // Load and build a bean plant
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Verify plant name is set correctly
    std::string plant_name = plantarchitecture.getPlantName(plantID);
    DOCTEST_CHECK(plant_name == "bean");
 
    // Advance time to create more organs
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 10.0f));
 
    // Get all object IDs
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
 
    // Verify plant_name object data is set on primitives
    bool found_plant_name_data = false;
    for (uint objID: all_primitives) {
        if (context.doesObjectDataExist(objID, "plant_name")) {
            std::string obj_plant_name;
            context.getObjectData(objID, "plant_name", obj_plant_name);
            DOCTEST_CHECK(obj_plant_name == "bean");
            found_plant_name_data = true;
        }
    }
    DOCTEST_CHECK(found_plant_name_data);
}
 
DOCTEST_TEST_CASE("PlantArchitecture plant_type tree classification") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable plant_type optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("plant_type"));
 
    // Test tree classification
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("almond"));
    uint treeID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(treeID != uint(-1));
 
    std::vector<uint> tree_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(tree_primitives.size() > 0);
    bool found_tree_type = false;
    for (uint objID: tree_primitives) {
        if (context.doesObjectDataExist(objID, "plant_type")) {
            std::string plant_type;
            context.getObjectData(objID, "plant_type", plant_type);
            DOCTEST_CHECK(plant_type == "tree");
            found_tree_type = true;
        }
    }
    DOCTEST_CHECK(found_tree_type);
}
 
DOCTEST_TEST_CASE("PlantArchitecture plant_type weed classification") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable plant_type optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("plant_type"));
 
    // Test weed classification
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bindweed"));
    uint weedID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(weedID != uint(-1));
 
    std::vector<uint> weed_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(weed_primitives.size() > 0);
    bool found_weed_type = false;
    for (uint objID: weed_primitives) {
        if (context.doesObjectDataExist(objID, "plant_type")) {
            std::string plant_type;
            context.getObjectData(objID, "plant_type", plant_type);
            DOCTEST_CHECK(plant_type == "weed");
            found_weed_type = true;
        }
    }
    DOCTEST_CHECK(found_weed_type);
}
 
DOCTEST_TEST_CASE("PlantArchitecture plant_type herbaceous classification") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable plant_type optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("plant_type"));
 
    // Test herbaceous classification (default)
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint herbaceousID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(herbaceousID != uint(-1));
 
    std::vector<uint> herbaceous_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(herbaceous_primitives.size() > 0);
    bool found_herbaceous_type = false;
    for (uint objID: herbaceous_primitives) {
        if (context.doesObjectDataExist(objID, "plant_type")) {
            std::string plant_type;
            context.getObjectData(objID, "plant_type", plant_type);
            DOCTEST_CHECK(plant_type == "herbaceous");
            found_herbaceous_type = true;
        }
    }
    DOCTEST_CHECK(found_herbaceous_type);
}
 
DOCTEST_TEST_CASE("PlantArchitecture plant_height optional object data") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable plant_height optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("plant_height"));
 
    // Build a bean plant
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Get initial height
    float initial_height = plantarchitecture.getPlantHeight(plantID);
    DOCTEST_CHECK(initial_height > 0);
 
    // Advance time to allow growth
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 10.0f));
 
    // Verify height increased
    float final_height = plantarchitecture.getPlantHeight(plantID);
    DOCTEST_CHECK(final_height > initial_height);
 
    // Verify plant_height object data was set and is reasonable
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
    bool found_height_data = false;
    for (uint objID: all_primitives) {
        if (context.doesObjectDataExist(objID, "plant_height")) {
            float obj_height;
            context.getObjectData(objID, "plant_height", obj_height);
            // Check height is within reasonable range (close to final_height)
            DOCTEST_CHECK(obj_height > initial_height);
            DOCTEST_CHECK(std::abs(obj_height - final_height) < 0.01f);
            found_height_data = true;
            break; // Only need to check one primitive
        }
    }
    DOCTEST_CHECK(found_height_data);
}
 
DOCTEST_TEST_CASE("PlantArchitecture phenology_stage optional object data") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable phenology_stage optional object data
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("phenology_stage"));
 
    // Build a bean plant
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Initially should be vegetative (no flowers, not dormant)
    std::string initial_stage = plantarchitecture.determinePhenologyStage(plantID);
    DOCTEST_CHECK(initial_stage == "vegetative");
 
    // Advance time to allow growth and potential flowering
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 20.0f));
 
    // Get current phenology stage
    std::string current_stage = plantarchitecture.determinePhenologyStage(plantID);
    DOCTEST_CHECK((current_stage == "vegetative" || current_stage == "reproductive" || current_stage == "senescent" || current_stage == "dormant"));
 
    // Verify phenology_stage object data was set
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
    bool found_stage_data = false;
    for (uint objID: all_primitives) {
        if (context.doesObjectDataExist(objID, "phenology_stage")) {
            std::string obj_stage;
            context.getObjectData(objID, "phenology_stage", obj_stage);
            DOCTEST_CHECK(obj_stage == current_stage);
            found_stage_data = true;
        }
    }
    DOCTEST_CHECK(found_stage_data);
}
 
DOCTEST_TEST_CASE("Build Parameters - Backward Compatibility (Grapevine VSP)") {
    // Test that empty parameter map produces identical plants to original hard-coded values
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Build with default parameters (empty map)
    plantarchitecture.loadPlantModelFromLibrary("grapevine_VSP");
    std::map<std::string, float> empty_params;
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0, empty_params);
 
    // Verify plant was created
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Verify basic plant structure exists
    std::vector<uint> plant_primitives = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_primitives.size() > 0);
}
 
DOCTEST_TEST_CASE("Build Parameters - Parameter Override (Grapevine VSP)") {
    // Test that custom parameter values are applied correctly
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Build with custom parameters
    // Note: vine_spacing limited by cane max_nodes (9) * internode_length (0.15m) * 2 = 2.7m max
    plantarchitecture.loadPlantModelFromLibrary("grapevine_VSP");
    std::map<std::string, float> custom_params = {
            {"vine_spacing", 2.5f}, // 2.5m spacing (within max_nodes limit)
            {"trunk_height", 0.15f} // 15 cm trunk height
    };
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0, custom_params);
 
    // Verify plant was created with custom parameters
    DOCTEST_CHECK(plantID != uint(-1));
    std::vector<uint> plant_primitives = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_primitives.size() > 0);
}
 
DOCTEST_TEST_CASE("Build Parameters - Validation Catches Invalid Values (Grapevine VSP)") {
    // Test that out-of-range values raise errors
    capture_cerr cerr_buffer;
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("grapevine_VSP");
 
    // Test vine_spacing out of range (valid range: 0.5-5.0)
    std::map<std::string, float> invalid_params1 = {{"vine_spacing", 10.0f}};
    DOCTEST_CHECK_THROWS(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0, invalid_params1));
 
    // Test trunk_height out of range (valid range: 0.05-1.0)
    std::map<std::string, float> invalid_params2 = {{"trunk_height", 2.0f}};
    DOCTEST_CHECK_THROWS(plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0, invalid_params2));
}
 
DOCTEST_TEST_CASE("Build Parameters - Grapevine Wye Trellis Parameters") {
    // Test Wye grapevine specific trellis parameters
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("grapevine_Wye");
    std::map<std::string, float> trellis_params = {
            {"trunk_height", 0.2f}, // 20 cm trunk height
            {"cordon_spacing", 0.8f}, // 80 cm between cordon rows
            {"vine_spacing", 2.0f}, // 2 m between plants
            {"catch_wire_height", 2.5f} // 2.5 m catch wire height
    };
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0, trellis_params);
 
    DOCTEST_CHECK(plantID != uint(-1));
    std::vector<uint> plant_primitives = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_primitives.size() > 0);
}
 
DOCTEST_TEST_CASE("Build Parameters - Tree Training System (Almond)") {
    // Test tree training parameters
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Note: trunk_height limited by trunk max_nodes (20) * internode_length (0.03m) = 0.6m max
    plantarchitecture.loadPlantModelFromLibrary("almond");
    std::map<std::string, float> tree_params = {
            {"trunk_height", 0.5f}, // 50 cm total trunk height (within max_nodes limit)
            {"num_scaffolds", 5.0f}, // 5 scaffold branches
            {"scaffold_angle", 35.0f} // 35 degree scaffold angle
    };
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000, tree_params);
 
    DOCTEST_CHECK(plantID != uint(-1));
    std::vector<uint> plant_primitives = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_primitives.size() > 0);
}
 
DOCTEST_TEST_CASE("Build Parameters - Apple Tree") {
    // Test apple tree with custom parameters
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Note: trunk_height limited by trunk max_nodes (20) * internode_length (0.04m) = 0.8m max
    plantarchitecture.loadPlantModelFromLibrary("apple");
    std::map<std::string, float> apple_params = {
            {"trunk_height", 0.7f}, // 70 cm trunk height (within max_nodes limit)
            {"num_scaffolds", 6.0f}, // 6 scaffold branches
            {"scaffold_angle", 45.0f} // 45 degree scaffold angle
    };
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000, apple_params);
 
    DOCTEST_CHECK(plantID != uint(-1));
}
 
DOCTEST_TEST_CASE("Build Parameters - Pistachio Tree Fixed Scaffold System") {
    // Test pistachio tree with different scaffold count
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("pistachio");
 
    // Test with 2 scaffolds (minimum)
    std::map<std::string, float> pistachio_params_min = {{"num_scaffolds", 2.0f}};
    uint plantID_min = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000, pistachio_params_min);
    DOCTEST_CHECK(plantID_min != uint(-1));
 
    // Test with 4 scaffolds (default)
    std::map<std::string, float> pistachio_params_def = {{"num_scaffolds", 4.0f}};
    uint plantID_def = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(5, 0, 0), 5000, pistachio_params_def);
    DOCTEST_CHECK(plantID_def != uint(-1));
}
 
DOCTEST_TEST_CASE("Build Parameters - Canopy Building with Parameters") {
    // Test that parameters work with canopy building functions
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("grapevine_VSP");
    std::map<std::string, float> canopy_params = {
            {"vine_spacing", 2.0f}, // 2.0m vine spacing
            {"trunk_height", 0.12f} // 12 cm trunk height
    };
 
    // Test regular spacing canopy
    std::vector<uint> plantIDs = plantarchitecture.buildPlantCanopyFromLibrary(make_vec3(0, 0, 0), make_vec2(2, 2), make_int2(2, 2), 0, 1.0f, canopy_params);
 
    DOCTEST_CHECK(plantIDs.size() == 4);
    for (uint plantID: plantIDs) {
        DOCTEST_CHECK(plantID != uint(-1));
    }
}
 
DOCTEST_TEST_CASE("Build Parameters - Type Casting Float to Uint") {
    // Test that float parameters correctly cast to uint for node counts
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.loadPlantModelFromLibrary("almond");
 
    // Specify parameters as floats (should cast to uint internally where needed)
    // Note: trunk_height limited by trunk max_nodes (20) * internode_length (0.03m) = 0.6m max
    std::map<std::string, float> float_params = {
            {"trunk_height", 0.5f}, // Height as float (within max_nodes limit)
            {"num_scaffolds", 5.0f}, // Should cast to uint(5)
            {"scaffold_angle", 42.5f} // Angle as float
    };
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000, float_params);
    DOCTEST_CHECK(plantID != uint(-1));
}
 
DOCTEST_TEST_CASE("PlantArchitecture optionalOutputObjectData 'all' keyword") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test that "all" (lowercase) enables all optional output data labels
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("all"));
 
    // Build a bean plant to verify data is actually being output
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Advance time to create some organs
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 10.0f));
 
    // Get all object IDs
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
 
    // Verify that basic metadata labels are present (these exist on all plants)
    // Note: Organ-specific labels (peduncleID, flowerID, fruitID) may not exist
    // if the plant hasn't developed those organs yet at this age
    std::vector<std::string> expected_labels = {"age", "rank", "plantID", "plant_name", "plant_height", "plant_type", "phenology_stage", "leafID"};
 
    for (const auto &label: expected_labels) {
        bool found = false;
        for (uint objID: all_primitives) {
            if (context.doesObjectDataExist(objID, label.c_str())) {
                found = true;
                break;
            }
        }
        DOCTEST_CHECK_MESSAGE(found, "Label '" << label << "' was not found on any primitive");
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture optionalOutputObjectData 'all' case-insensitive") {
    // Test "ALL" (uppercase)
    {
        Context context;
        PlantArchitecture plantarchitecture(&context);
        plantarchitecture.disableMessages();
        DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("ALL"));
    }
 
    // Test "All" (mixed case)
    {
        Context context;
        PlantArchitecture plantarchitecture(&context);
        plantarchitecture.disableMessages();
        DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("All"));
    }
 
    // Test "aLl" (random mixed case)
    {
        Context context;
        PlantArchitecture plantarchitecture(&context);
        plantarchitecture.disableMessages();
        DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("aLl"));
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture optionalOutputObjectData invalid label throws error") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test that an invalid label throws a helios_runtime_error with descriptive message
    bool caught_error = false;
    try {
        plantarchitecture.optionalOutputObjectData("invalid_label");
    } catch (const std::exception &e) {
        caught_error = true;
        std::string error_msg(e.what());
        DOCTEST_CHECK(error_msg.find("invalid_label") != std::string::npos);
        DOCTEST_CHECK(error_msg.find("not a valid option") != std::string::npos);
    }
    DOCTEST_CHECK(caught_error);
 
    // Note: helios_runtime_error() only writes to stderr when HELIOS_DEBUG is defined,
    // so we don't check stderr output here - just verify the exception is thrown correctly
}
 
DOCTEST_TEST_CASE("PlantArchitecture optionalOutputObjectData vector with 'all'") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test that "all" works in a vector of labels
    std::vector<std::string> labels = {"all"};
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData(labels));
 
    // Build a bean plant to verify data is actually being output
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Advance time to create more organs
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 10.0f));
 
    // Get all object IDs
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
 
    // Verify that at least a few optional output data labels are present
    bool found_age = false;
    bool found_rank = false;
    bool found_plant_name = false;
    for (uint objID: all_primitives) {
        if (context.doesObjectDataExist(objID, "age"))
            found_age = true;
        if (context.doesObjectDataExist(objID, "rank"))
            found_rank = true;
        if (context.doesObjectDataExist(objID, "plant_name"))
            found_plant_name = true;
    }
    DOCTEST_CHECK(found_age);
    DOCTEST_CHECK(found_rank);
    DOCTEST_CHECK(found_plant_name);
}
 
DOCTEST_TEST_CASE("PlantArchitecture optionalOutputObjectData normal labels still work") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Test that individual labels still work as expected
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("age"));
    DOCTEST_CHECK_NOTHROW(plantarchitecture.optionalOutputObjectData("rank"));
 
    // Build a bean plant
    DOCTEST_CHECK_NOTHROW(plantarchitecture.loadPlantModelFromLibrary("bean"));
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    DOCTEST_CHECK(plantID != uint(-1));
 
    // Advance time
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 5.0f));
 
    // Verify that age and rank data exist, but other optional data does not
    std::vector<uint> all_primitives = plantarchitecture.getAllObjectIDs();
    DOCTEST_CHECK(all_primitives.size() > 0);
 
    bool found_age = false;
    bool found_rank = false;
    bool found_plant_name = false; // This should NOT be found
    for (uint objID: all_primitives) {
        if (context.doesObjectDataExist(objID, "age"))
            found_age = true;
        if (context.doesObjectDataExist(objID, "rank"))
            found_rank = true;
        if (context.doesObjectDataExist(objID, "plant_name"))
            found_plant_name = true;
    }
    DOCTEST_CHECK(found_age);
    DOCTEST_CHECK(found_rank);
    DOCTEST_CHECK_FALSE(found_plant_name); // Should NOT be enabled
}
 
// ==================== NITROGEN MODEL TESTS ==================== //
 
DOCTEST_TEST_CASE("Nitrogen Model - Initialization") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Enable nitrogen model
    plantarchitecture.enableNitrogenModel();
    DOCTEST_CHECK(plantarchitecture.isNitrogenModelEnabled());
 
    // Build a simple plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Grow plant to create leaves
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize nitrogen pools with target concentration
    float initial_N_concentration = 1.5f; // g N/m² (target value)
    plantarchitecture.initializePlantNitrogenPools(plantID, initial_N_concentration);
 
    // Advance time to trigger nitrogen stress calculation and output writing
    plantarchitecture.advanceTime(plantID, 0.1f);
 
    // Get all leaf objects
    std::vector<uint> all_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(all_objects.size() > 0);
 
    // Verify leaf nitrogen content was initialized
    bool found_leaf_N = false;
    for (uint objID: all_objects) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            DOCTEST_CHECK(leaf_N_area == doctest::Approx(initial_N_concentration).epsilon(0.1));
            found_leaf_N = true;
        }
    }
    DOCTEST_CHECK(found_leaf_N);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Application and Pool Splitting") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 3.0f);
 
    // Initialize with zero nitrogen
    plantarchitecture.initializePlantNitrogenPools(plantID, 0.0f);
 
    // Apply 10 g N to plant
    float N_applied = 10.0f; // g N
    plantarchitecture.addPlantNitrogen(plantID, N_applied);
 
    // Verify nitrogen was split between root (15%) and available (85%) pools
    // We can't directly access the pools, but we can verify by advancing time
    // and checking that leaves accumulate nitrogen from the available pool
    plantarchitecture.advanceTime(plantID, 1.0f);
 
    // Check that leaves now have nitrogen > 0
    std::vector<uint> all_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    bool found_N_accumulation = false;
    for (uint objID: all_objects) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            if (leaf_N_area > 0) {
                found_N_accumulation = true;
                break;
            }
        }
    }
    DOCTEST_CHECK(found_N_accumulation);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Rate Limiting") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize with zero nitrogen
    plantarchitecture.initializePlantNitrogenPools(plantID, 0.0f);
 
    // Set nitrogen parameters with known max accumulation rate
    NitrogenParameters N_params;
    N_params.max_N_accumulation_rate = 0.1f; // g N/m²/day
    N_params.target_leaf_N_area = 10.0f; // Very high target to ensure demand > rate
    plantarchitecture.setPlantNitrogenParameters(plantID, N_params);
 
    // Apply large amount of nitrogen
    plantarchitecture.addPlantNitrogen(plantID, 100.0f);
 
    // Advance time by 1 day
    float dt = 1.0f;
    plantarchitecture.advanceTime(plantID, dt);
 
    // Check that leaf nitrogen didn't exceed rate limit
    std::vector<uint> all_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    for (uint objID: all_objects) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            // Should be at most max_N_accumulation_rate * dt
            DOCTEST_CHECK(leaf_N_area <= N_params.max_N_accumulation_rate * dt * 1.01f); // 1% tolerance
        }
    }
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Stress Factor Output") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize with low nitrogen (stress condition)
    plantarchitecture.initializePlantNitrogenPools(plantID, 0.5f); // Below target of 1.5
 
    // Advance time to trigger stress factor calculation
    plantarchitecture.advanceTime(plantID, 0.1f);
 
    // Verify stress factor exists and is in valid range [0, 1]
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    bool found_stress_factor = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            float stress_factor;
            context.getObjectData(objID, "nitrogen_stress_factor", stress_factor);
            DOCTEST_CHECK(stress_factor >= 0.0f);
            DOCTEST_CHECK(stress_factor <= 1.0f);
            // With low N, stress should be less than 1
            DOCTEST_CHECK(stress_factor < 1.0f);
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Remobilization") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Grow plant to create leaves of different ages
    plantarchitecture.advanceTime(plantID, 15.0f);
 
    // Initialize with low nitrogen to create stress condition
    plantarchitecture.initializePlantNitrogenPools(plantID, 0.8f); // Below target
 
    // Advance time significantly to age leaves and trigger remobilization
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 25.0f));
 
    // Verify nitrogen stress factor reflects stress condition
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    bool found_stress_factor = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            float stress_factor;
            context.getObjectData(objID, "nitrogen_stress_factor", stress_factor);
            DOCTEST_CHECK(stress_factor < 1.0f); // Should indicate some stress
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Fruit Removal") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
 
    // Use tomato which produces fruit
    plantarchitecture.loadPlantModelFromLibrary("tomato");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Grow plant to vegetative stage
    plantarchitecture.advanceTime(plantID, 30.0f);
 
    // Initialize with adequate nitrogen
    plantarchitecture.initializePlantNitrogenPools(plantID, 1.5f);
 
    // Add nitrogen to available pool
    plantarchitecture.addPlantNitrogen(plantID, 50.0f);
 
    // Continue growth to allow fruiting
    plantarchitecture.advanceTime(plantID, 40.0f);
 
    // Verify plant grew (basic sanity check)
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Nitrogen stress factor should exist
    bool found_stress_factor = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Leaf-to-Fruit Translocation") {
    // When the available nitrogen pool cannot cover fruit demand, removeFruitNitrogen draws the
    // shortfall from leaves (old leaves first, then young leaves as fallback). To isolate
    // translocation cleanly, we override remobilization_age_threshold to a value age_fraction
    // never reaches, which disables the leaf-to-leaf remobilization pathway. With remobilization
    // disabled and the available pool empty, the only mechanism that can reduce a leaf below the
    // target N concentration is leaf-to-fruit translocation.
 
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("tomato");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Disable leaf-to-leaf remobilization by setting an unreachable age threshold (age_fraction <= 1).
    NitrogenParameters N_params; // defaults: target=1.5, minimum=0.5, efficiency=0.7
    N_params.remobilization_age_threshold = 2.0f;
    plantarchitecture.setPlantNitrogenParameters(plantID, N_params);
 
    // Grow plant well past fruit-set so fruits exist when we initialize and snapshot.
    // Tomato in this library typically starts fruit set around day 40-50; advance past that.
    plantarchitecture.advanceTime(plantID, 60.0f);
 
    // Skip the test if the plant did not produce fruit in this run (random plant growth can
    // sometimes produce no fruits within the window). The translocation pathway only exercises
    // when fruits actively grow, so we need fruits to be present.
    std::vector<uint> fruit_objIDs = plantarchitecture.getPlantFruitObjectIDs(plantID);
    if (fruit_objIDs.empty()) {
        // Try a longer window before giving up.
        plantarchitecture.advanceTime(plantID, 30.0f);
        fruit_objIDs = plantarchitecture.getPlantFruitObjectIDs(plantID);
    }
    if (fruit_objIDs.empty()) {
        return; // No fruits formed in this run; nothing to test.
    }
 
    // Reset leaves to target N (overwrites any drainage that occurred during the warm-up advance);
    // do NOT call addPlantNitrogen so the available pool stays empty and any further fruit demand
    // must come from leaves via translocation.
    plantarchitecture.initializePlantNitrogenPools(plantID, N_params.target_leaf_N_area);
 
    // Trigger an output write so leaf_nitrogen_gN_m2 is materialized as object data
    plantarchitecture.advanceTime(plantID, 0.1f);
 
    // Sanity: at least one leaf is at the target initially
    bool any_leaf_at_target_pre = false;
    for (uint objID: plantarchitecture.getAllPlantObjectIDs(plantID)) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            if (std::abs(leaf_N_area - N_params.target_leaf_N_area) < 0.01f) {
                any_leaf_at_target_pre = true;
                break;
            }
        }
    }
    DOCTEST_CHECK(any_leaf_at_target_pre);
 
    // Advance through ongoing fruit growth. With remobilization disabled and the pool empty, the
    // only path that can drop a leaf below target is translocation to fruit.
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 30.0f));
 
    // Look for evidence of translocation: at least one leaf that started at target now sits below
    // it (but at or above the per-leaf floor). Newly grown leaves with N == 0 are excluded by
    // requiring leaf_N_area > minimum_leaf_N_area.
    bool any_leaf_drained_below_target = false;
    float min_leaf_N_observed = std::numeric_limits<float>::infinity();
    bool any_leaf_with_N = false;
    for (uint objID: plantarchitecture.getAllPlantObjectIDs(plantID)) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            if (leaf_N_area > N_params.minimum_leaf_N_area && leaf_N_area < N_params.target_leaf_N_area - 0.01f) {
                any_leaf_drained_below_target = true;
            }
            if (leaf_N_area > 1e-4f) {
                min_leaf_N_observed = std::min(min_leaf_N_observed, leaf_N_area);
                any_leaf_with_N = true;
            }
        }
    }
 
    // Confirm fruits still exist at the end of the test window (sanity check that fruit demand
    // was active for at least part of the post-advance period).
    fruit_objIDs = plantarchitecture.getPlantFruitObjectIDs(plantID);
 
    // Translocation drained at least one initialized leaf below the target.
    if (!fruit_objIDs.empty()) {
        DOCTEST_CHECK(any_leaf_drained_below_target);
    }
 
    // Per-leaf floor: with translocation only able to remove (current - minimum) * efficiency, a
    // fully drained leaf bottoms out at minimum + (initial - minimum)(1 - efficiency) = 0.8 g N/m²
    // for the defaults. Assert at least minimum_leaf_N_area as a slack lower bound.
    if (any_leaf_with_N) {
        DOCTEST_CHECK(min_leaf_N_observed >= N_params.minimum_leaf_N_area - 1e-3f);
    }
 
    // Stress factor output still written
    bool found_stress_factor = false;
    for (uint objID: plantarchitecture.getAllPlantObjectIDs(plantID)) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - No Translocation When Pool Adequate") {
    // Negative control: with leaf-to-leaf remobilization disabled (unreachable threshold) AND a
    // well-stocked available pool, no drainage pathway should be active. Pre-existing leaves at
    // target N must remain at target after fruiting (translocation never triggers because the pool
    // covers demand). New leaves grown later may have lower N because accumulation is rate-limited,
    // so we only check the pre-existing initialized leaves.
 
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("tomato");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    NitrogenParameters N_params;
    N_params.remobilization_age_threshold = 2.0f; // Disable leaf-to-leaf remobilization
    plantarchitecture.setPlantNitrogenParameters(plantID, N_params);
 
    plantarchitecture.advanceTime(plantID, 30.0f);
    plantarchitecture.initializePlantNitrogenPools(plantID, N_params.target_leaf_N_area);
    plantarchitecture.addPlantNitrogen(plantID, 200.0f); // Generously stock so pool always covers fruit demand
    plantarchitecture.advanceTime(plantID, 0.1f);        // Materialize object data
 
    // Capture pre-existing leaves that are at the target N concentration
    std::vector<uint> leaves_at_target_pre;
    for (uint objID: plantarchitecture.getAllPlantObjectIDs(plantID)) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N_area;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
            if (std::abs(leaf_N_area - N_params.target_leaf_N_area) < 0.01f) {
                leaves_at_target_pre.push_back(objID);
            }
        }
    }
    DOCTEST_CHECK(leaves_at_target_pre.size() > 0);
 
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 40.0f));
 
    // Pre-existing leaves at target should remain at (or very near) target. With remobilization
    // disabled and the pool adequate to cover fruit demand, no drainage pathway is active.
    int leaves_intact = 0;
    for (uint objID: leaves_at_target_pre) {
        if (!context.doesObjectExist(objID)) {
            continue;
        }
        if (!context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            continue;
        }
        float leaf_N_area;
        context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N_area);
        if (leaf_N_area >= N_params.target_leaf_N_area - 0.05f) {
            leaves_intact++;
        }
    }
    DOCTEST_CHECK(leaves_intact > 0);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Full Growth Cycle Integration") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Initial growth
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize nitrogen
    plantarchitecture.initializePlantNitrogenPools(plantID, 1.0f);
 
    // Simulate periodic nitrogen applications during growth
    for (int i = 0; i < 5; i++) {
        plantarchitecture.addPlantNitrogen(plantID, 5.0f); // Add 5 g N
        plantarchitecture.advanceTime(plantID, 5.0f); // Grow 5 days
    }
 
    // Verify plant completed growth cycle
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    DOCTEST_CHECK(plant_objects.size() > 0);
 
    // Verify stress factor updated throughout
    bool found_stress_factor = false;
    float final_stress = 0;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            context.getObjectData(objID, "nitrogen_stress_factor", final_stress);
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
    DOCTEST_CHECK(final_stress >= 0.0f);
    DOCTEST_CHECK(final_stress <= 1.0f);
 
    // Verify leaves have nitrogen data
    bool found_leaf_N = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "leaf_nitrogen_gN_m2")) {
            float leaf_N;
            context.getObjectData(objID, "leaf_nitrogen_gN_m2", leaf_N);
            DOCTEST_CHECK(leaf_N >= 0.0f);
            found_leaf_N = true;
        }
    }
    DOCTEST_CHECK(found_leaf_N);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Edge Case: Zero Nitrogen") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize with zero nitrogen - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.initializePlantNitrogenPools(plantID, 0.0f));
 
    // Advance time with zero nitrogen - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 5.0f));
 
    // Stress factor should be very low (severe stress)
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    bool found_stress_factor = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            float stress_factor;
            context.getObjectData(objID, "nitrogen_stress_factor", stress_factor);
            DOCTEST_CHECK(stress_factor < 0.2f); // Should be low under zero N
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Edge Case: Excessive Nitrogen") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    // Initialize with zero
    plantarchitecture.initializePlantNitrogenPools(plantID, 0.0f);
 
    // Set high accumulation rate to overcome rate limiting
    NitrogenParameters N_params;
    N_params.max_N_accumulation_rate = 1.0f; // g N/m²/day (10x default)
    plantarchitecture.setPlantNitrogenParameters(plantID, N_params);
 
    // Apply excessive nitrogen - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.addPlantNitrogen(plantID, 1000.0f));
 
    // Advance time - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 5.0f));
 
    // Stress factor should clamp at 1.0 (no stress) and be high with excess N
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    bool found_stress_factor = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            float stress_factor;
            context.getObjectData(objID, "nitrogen_stress_factor", stress_factor);
            DOCTEST_CHECK(stress_factor <= 1.0f); // Should clamp at 1.0
            DOCTEST_CHECK(stress_factor >= 0.90f); // Should be very high with excess N and fast accumulation
            found_stress_factor = true;
            break;
        }
    }
    DOCTEST_CHECK(found_stress_factor);
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Edge Case: No Leaves") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
 
    // Build plant at very early stage (no leaves yet)
    uint plantID = plantarchitecture.addPlantInstance(make_vec3(0, 0, 0), 0);
 
    // Try to initialize nitrogen - should not crash even with no leaves
    DOCTEST_CHECK_NOTHROW(plantarchitecture.initializePlantNitrogenPools(plantID, 1.5f));
 
    // Add nitrogen - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.addPlantNitrogen(plantID, 10.0f));
 
    // Advance time with no leaves - should not crash
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 1.0f));
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Division by Zero Prevention") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    plantarchitecture.enableNitrogenModel();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Grow plant slightly to create very small leaves
    plantarchitecture.advanceTime(plantID, 0.5f);
 
    // Initialize nitrogen
    plantarchitecture.initializePlantNitrogenPools(plantID, 1.5f);
 
    // Add nitrogen and advance - should handle small/zero leaf areas gracefully
    plantarchitecture.addPlantNitrogen(plantID, 10.0f);
 
    // This should not crash due to division by zero (bug fix verification)
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 1.0f));
 
    // Continue growth and check remobilization doesn't crash either
    plantarchitecture.advanceTime(plantID, 20.0f);
    DOCTEST_CHECK_NOTHROW(plantarchitecture.advanceTime(plantID, 5.0f));
}
 
DOCTEST_TEST_CASE("Nitrogen Model - Enable/Disable") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Initially disabled
    DOCTEST_CHECK_FALSE(plantarchitecture.isNitrogenModelEnabled());
 
    // Enable
    plantarchitecture.enableNitrogenModel();
    DOCTEST_CHECK(plantarchitecture.isNitrogenModelEnabled());
 
    // Disable
    plantarchitecture.disableNitrogenModel();
    DOCTEST_CHECK_FALSE(plantarchitecture.isNitrogenModelEnabled());
 
    // Build plant with model disabled - should not output nitrogen data
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
    plantarchitecture.advanceTime(plantID, 5.0f);
 
    std::vector<uint> plant_objects = plantarchitecture.getAllPlantObjectIDs(plantID);
    bool found_nitrogen_data = false;
    for (uint objID: plant_objects) {
        if (context.doesObjectDataExist(objID, "nitrogen_stress_factor")) {
            found_nitrogen_data = true;
            break;
        }
    }
    DOCTEST_CHECK_FALSE(found_nitrogen_data); // Should NOT have nitrogen data when disabled
}
 
// ===== Tests for listShootTypeLabels() methods =====
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - no parameter success") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    plantarchitecture.loadPlantModelFromLibrary("bean");
    std::vector<std::string> labels = plantarchitecture.listShootTypeLabels();
 
    DOCTEST_CHECK(labels.size() == 2);
    DOCTEST_CHECK(std::find(labels.begin(), labels.end(), "unifoliate") != labels.end());
    DOCTEST_CHECK(std::find(labels.begin(), labels.end(), "trifoliate") != labels.end());
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - no parameter error") {
    std::string error_message;
    {
        capture_cerr cerr_buffer;
        Context context;
        PlantArchitecture plantarchitecture(&context);
 
        // Should throw because no plant model is loaded
        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.listShootTypeLabels()));
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - string parameter success") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Query bean shoot types without loading it
    std::vector<std::string> bean_labels = plantarchitecture.listShootTypeLabels("bean");
    DOCTEST_CHECK(bean_labels.size() == 2);
    DOCTEST_CHECK(std::find(bean_labels.begin(), bean_labels.end(), "unifoliate") != bean_labels.end());
    DOCTEST_CHECK(std::find(bean_labels.begin(), bean_labels.end(), "trifoliate") != bean_labels.end());
 
    // Query tomato shoot types
    std::vector<std::string> tomato_labels = plantarchitecture.listShootTypeLabels("tomato");
    DOCTEST_CHECK(tomato_labels.size() == 1);
    DOCTEST_CHECK(std::find(tomato_labels.begin(), tomato_labels.end(), "mainstem") != tomato_labels.end());
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - string parameter error") {
    std::string error_message;
    {
        capture_cerr cerr_buffer;
        Context context;
        PlantArchitecture plantarchitecture(&context);
 
        // Should throw for non-existent plant model
        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.listShootTypeLabels("nonexistent_plant")));
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - state preservation") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Load bean plant model
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    // Query tomato shoot types (should not change current plant model)
    std::vector<std::string> tomato_labels = plantarchitecture.listShootTypeLabels("tomato");
 
    // Verify bean is still loaded by checking current labels
    std::vector<std::string> current_labels = plantarchitecture.listShootTypeLabels();
    DOCTEST_CHECK(current_labels.size() == 2);
    DOCTEST_CHECK(std::find(current_labels.begin(), current_labels.end(), "unifoliate") != current_labels.end());
    DOCTEST_CHECK(std::find(current_labels.begin(), current_labels.end(), "trifoliate") != current_labels.end());
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - all plant models") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    std::vector<std::string> all_plants = plantarchitecture.getAvailablePlantModels();
 
    // Should successfully query shoot types for all plants
    for (const auto &plant: all_plants) {
        std::vector<std::string> labels;
        DOCTEST_CHECK_NOTHROW(labels = plantarchitecture.listShootTypeLabels(plant));
        DOCTEST_CHECK(!labels.empty()); // All plants should have at least one shoot type
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - uint parameter success") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Load and build bean plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Query by plantID
    std::vector<std::string> labels = plantarchitecture.listShootTypeLabels(plantID);
 
    // Should match bean model shoot types
    DOCTEST_CHECK(labels.size() == 2);
    DOCTEST_CHECK(std::find(labels.begin(), labels.end(), "unifoliate") != labels.end());
    DOCTEST_CHECK(std::find(labels.begin(), labels.end(), "trifoliate") != labels.end());
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - uint parameter error") {
    std::string error_message;
    {
        capture_cerr cerr_buffer;
        Context context;
        PlantArchitecture plantarchitecture(&context);
 
        // Should throw for invalid plantID
        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.listShootTypeLabels(999)));
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture listShootTypeLabels - multiple instances") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Build bean plant
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint bean_plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0);
 
    // Build tomato plant
    plantarchitecture.loadPlantModelFromLibrary("tomato");
    uint tomato_plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(1, 0, 0), 0);
 
    // Verify each returns correct labels for its model
    std::vector<std::string> bean_labels = plantarchitecture.listShootTypeLabels(bean_plantID);
    DOCTEST_CHECK(bean_labels.size() == 2);
    DOCTEST_CHECK(std::find(bean_labels.begin(), bean_labels.end(), "unifoliate") != bean_labels.end());
    DOCTEST_CHECK(std::find(bean_labels.begin(), bean_labels.end(), "trifoliate") != bean_labels.end());
 
    std::vector<std::string> tomato_labels = plantarchitecture.listShootTypeLabels(tomato_plantID);
    DOCTEST_CHECK(tomato_labels.size() == 1);
    DOCTEST_CHECK(std::find(tomato_labels.begin(), tomato_labels.end(), "mainstem") != tomato_labels.end());
}
 
DOCTEST_TEST_CASE("PlantArchitecture getPlantInternodeObjectIDs with shoot type filter") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
 
    // Build a bean plant (has two shoot types: "unifoliate" and "trifoliate")
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0.0);
 
    // Get all internode object IDs without filter
    std::vector<uint> all_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID);
    DOCTEST_CHECK(all_internodes.size() > 0);
 
    // Get internode object IDs for "unifoliate" shoot type
    std::vector<uint> unifoliate_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID, "unifoliate");
    DOCTEST_CHECK(unifoliate_internodes.size() > 0);
 
    // Get internode object IDs for "trifoliate" shoot type
    std::vector<uint> trifoliate_internodes = plantarchitecture.getPlantInternodeObjectIDs(plantID, "trifoliate");
    DOCTEST_CHECK(trifoliate_internodes.size() > 0);
 
    // Verify that filtered results are subsets of all internodes
    for (uint objID : unifoliate_internodes) {
        DOCTEST_CHECK(std::find(all_internodes.begin(), all_internodes.end(), objID) != all_internodes.end());
    }
    for (uint objID : trifoliate_internodes) {
        DOCTEST_CHECK(std::find(all_internodes.begin(), all_internodes.end(), objID) != all_internodes.end());
    }
 
    // Verify no overlap between unifoliate and trifoliate internodes
    for (uint objID : unifoliate_internodes) {
        DOCTEST_CHECK(std::find(trifoliate_internodes.begin(), trifoliate_internodes.end(), objID) == trifoliate_internodes.end());
    }
 
    // Verify that sum of filtered internodes equals total internodes
    DOCTEST_CHECK(unifoliate_internodes.size() + trifoliate_internodes.size() == all_internodes.size());
}
 
DOCTEST_TEST_CASE("PlantArchitecture getPlantInternodeObjectIDs with shoot type filter - error cases") {
    std::string error_message;
    {
        capture_cerr cerr_buffer;
        Context context;
        PlantArchitecture plantarchitecture(&context);
 
        plantarchitecture.loadPlantModelFromLibrary("bean");
        uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 0.0);
 
        // Should throw for non-existent shoot type
        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.getPlantInternodeObjectIDs(plantID, "nonexistent_shoot_type")));
 
        // Should throw for invalid plant ID
        DOCTEST_CHECK_THROWS(static_cast<void>(plantarchitecture.getPlantInternodeObjectIDs(9999, "unifoliate")));
    }
}
 
DOCTEST_TEST_CASE("PlantArchitecture setProgressCallback") {
    std::vector<float> progress_values;
    std::vector<std::string> messages;
    {
        capture_cout cout_buffer;
        capture_cerr cerr_buffer;
 
        Context context;
        PlantArchitecture plantarchitecture(&context);
        plantarchitecture.disableMessages();
 
        plantarchitecture.setProgressCallback([&](float progress, const std::string &msg) {
            progress_values.push_back(progress);
            messages.push_back(msg);
        });
 
        plantarchitecture.loadPlantModelFromLibrary("bean");
        plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5);
 
        // advanceTime should trigger the callback
        plantarchitecture.advanceTime(1.f);
    }
 
    // Verify callback was invoked
    DOCTEST_CHECK(progress_values.size() > 0);
 
    // Verify progress values are in [0, 1]
    for (float p : progress_values) {
        DOCTEST_CHECK(p >= 0.f);
        DOCTEST_CHECK(p <= 1.f);
    }
 
    // Verify the last progress value is 1.0 (complete)
    if (!progress_values.empty()) {
        DOCTEST_CHECK(progress_values.back() == doctest::Approx(1.0f));
    }
 
    // Verify messages are non-empty
    for (const auto &msg : messages) {
        DOCTEST_CHECK(!msg.empty());
    }
}
 
DOCTEST_TEST_CASE("getAllPlantUUIDs with include_hidden parameter") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
 
    std::vector<uint> uuids_default = plantarchitecture.getAllPlantUUIDs(plantID);
    std::vector<uint> uuids_no_hidden = plantarchitecture.getAllPlantUUIDs(plantID, false);
    std::vector<uint> uuids_with_hidden = plantarchitecture.getAllPlantUUIDs(plantID, true);
 
    // Default behavior should match explicit false
    DOCTEST_CHECK(uuids_default.size() == uuids_no_hidden.size());
 
    // include_hidden=true should return more UUIDs (the hidden prototypes)
    DOCTEST_CHECK(uuids_with_hidden.size() > uuids_no_hidden.size());
}
 
DOCTEST_TEST_CASE("deletePlantInstance cleans up prototypes when all plants deleted") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID1 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
    uint plantID2 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(1, 0, 0), 5000);
 
    // Identify hidden prototype UUIDs
    std::vector<uint> all_uuids = plantarchitecture.getAllPlantUUIDs(plantID1, true);
    std::vector<uint> visible_uuids = plantarchitecture.getAllPlantUUIDs(plantID1, false);
    DOCTEST_CHECK(all_uuids.size() > visible_uuids.size());
 
    // Collect prototype UUIDs (those in all but not in visible)
    std::set<uint> visible_set(visible_uuids.begin(), visible_uuids.end());
    std::vector<uint> prototype_uuids;
    for (uint uuid : all_uuids) {
        if (visible_set.find(uuid) == visible_set.end()) {
            prototype_uuids.push_back(uuid);
        }
    }
    DOCTEST_CHECK(prototype_uuids.size() > 0);
 
    // Delete first plant — prototypes should survive
    plantarchitecture.deletePlantInstance(plantID1);
    for (uint uuid : prototype_uuids) {
        DOCTEST_CHECK(context.doesPrimitiveExist(uuid));
    }
 
    // Delete second plant — prototypes should now be cleaned up
    plantarchitecture.deletePlantInstance(plantID2);
    for (uint uuid : prototype_uuids) {
        DOCTEST_CHECK(!context.doesPrimitiveExist(uuid));
    }
}
 
DOCTEST_TEST_CASE("deletePlantInstance preserves prototypes when plants remain") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID1 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 5000);
    uint plantID2 = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(1, 0, 0), 5000);
 
    // Get prototype UUIDs via the second plant
    std::vector<uint> uuids_with_hidden = plantarchitecture.getAllPlantUUIDs(plantID2, true);
    std::vector<uint> uuids_without_hidden = plantarchitecture.getAllPlantUUIDs(plantID2, false);
    DOCTEST_CHECK(uuids_with_hidden.size() > uuids_without_hidden.size());
 
    // Delete first plant — prototypes should still be accessible for remaining plant
    plantarchitecture.deletePlantInstance(plantID1);
 
    std::vector<uint> uuids_after = plantarchitecture.getAllPlantUUIDs(plantID2, true);
    DOCTEST_CHECK(uuids_after.size() > plantarchitecture.getAllPlantUUIDs(plantID2, false).size());
}
 
DOCTEST_TEST_CASE("USD export basic structure") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    std::string filename = "test_usd_basic.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename);
 
    // Read the file and verify key structural elements
    std::ifstream file(filename);
    DOCTEST_CHECK(file.is_open());
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
    DOCTEST_CHECK(!content.empty());
 
    // Check required USD elements
    DOCTEST_CHECK(content.find("PhysicsArticulationRootAPI") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysxArticulationAPI") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsScene") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsMaterialAPI") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsFixedJoint") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsRigidBodyAPI") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsSphericalJoint") != std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsDriveAPI:angular") != std::string::npos);
 
    // Count links (each has PhysicsRigidBodyAPI)
    size_t link_count = 0;
    size_t pos = 0;
    while ((pos = content.find("PhysicsRigidBodyAPI", pos)) != std::string::npos) {
        link_count++;
        pos++;
    }
    DOCTEST_CHECK(link_count > 0);
 
    // Verify exactly one fixed joint (world anchor)
    size_t fixed_count = 0;
    pos = 0;
    while ((pos = content.find("PhysicsFixedJoint", pos)) != std::string::npos) {
        fixed_count++;
        pos++;
    }
    DOCTEST_CHECK(fixed_count == 1);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("USD export physics properties") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    USDExportParameters params;
    params.elastic_modulus = 1e9f;
    params.wood_density = 500.f;
 
    std::string filename = "test_usd_physics.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename, params);
 
    // Read and verify physics values are present and positive
    std::ifstream file(filename);
    DOCTEST_CHECK(file.is_open());
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Check that mass values exist and stiffness values exist
    DOCTEST_CHECK(content.find("physics:mass") != std::string::npos);
    DOCTEST_CHECK(content.find("drive:angular:physics:stiffness") != std::string::npos);
    DOCTEST_CHECK(content.find("drive:angular:physics:damping") != std::string::npos);
 
    // Check that gravity is correct
    DOCTEST_CHECK(content.find("physics:gravityMagnitude = 9.81") != std::string::npos);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("USD export branching topology") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Use almond which has branching structure
    plantarchitecture.loadPlantModelFromLibrary("almond");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    std::string filename = "test_usd_branching.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename);
 
    std::ifstream file(filename);
    DOCTEST_CHECK(file.is_open());
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Should have multiple links and joints
    size_t link_count = 0;
    size_t pos = 0;
    while ((pos = content.find("PhysicsRigidBodyAPI", pos)) != std::string::npos) {
        link_count++;
        pos++;
    }
    DOCTEST_CHECK(link_count > 3);
 
    // Check that body0 and body1 references exist (proper joint connectivity)
    DOCTEST_CHECK(content.find("physics:body0") != std::string::npos);
    DOCTEST_CHECK(content.find("physics:body1") != std::string::npos);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("USD export error handling") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Invalid plant ID
    DOCTEST_CHECK_THROWS(plantarchitecture.writePlantStructureUSD(9999, "test.usda"));
 
    // Build a plant first, then test empty filename
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    // Invalid file extension (only .usda/.USDA are accepted)
    DOCTEST_CHECK_THROWS(plantarchitecture.writePlantStructureUSD(plantID, "test.txt"));
}
 
DOCTEST_TEST_CASE("USD export organs") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    USDExportParameters params;
    std::string filename = "test_usd_organs.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename, params);
 
    std::ifstream file(filename);
    DOCTEST_CHECK(file.is_open());
 
    std::string content((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
    file.close();
 
    // Bean should have petiole segments
    DOCTEST_CHECK(content.find("Pet") != std::string::npos);
 
    // Bean should have leaves with both Visual and Collision mesh prims
    DOCTEST_CHECK(content.find("Leaf") != std::string::npos);
    DOCTEST_CHECK(content.find("def Mesh \"Visual\"") != std::string::npos);
    DOCTEST_CHECK(content.find("def Mesh \"Collision\"") != std::string::npos);
 
    // All mesh/capsule prims with material bindings must declare MaterialBindingAPI
    DOCTEST_CHECK(content.find("\"MaterialBindingAPI\"") != std::string::npos);
 
    // Visual meshes must have doubleSided and correct subdivision for Isaac Sim
    DOCTEST_CHECK(content.find("bool doubleSided = 1") != std::string::npos);
    DOCTEST_CHECK(content.find("subdivisionScheme = \"none\"") != std::string::npos);
 
    // Normals must be present for correct shading
    DOCTEST_CHECK(content.find("primvars:normals") != std::string::npos);
 
    // Texture paths must be relative (no absolute paths starting with /)
    DOCTEST_CHECK(content.find("asset inputs:file = @/") == std::string::npos);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("USD export minimum segment filtering") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    // Use almond which has longer internode segments than bean, so both default and
    // stricter filters always leave at least one surviving segment to export.
    plantarchitecture.loadPlantModelFromLibrary("almond");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    // Export with default min_segment_length
    USDExportParameters params_default;
    std::string filename_default = "test_usd_filter_default.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename_default, params_default);
 
    // Export with larger min_segment_length — should produce fewer links
    USDExportParameters params_strict;
    params_strict.min_segment_length = 0.05f; // 5 cm — filters short segments
    std::string filename_strict = "test_usd_filter_strict.usda";
    plantarchitecture.writePlantStructureUSD(plantID, filename_strict, params_strict);
 
    // Count links in each file
    auto countOccurrences = [](const std::string &content, const std::string &token) {
        size_t count = 0;
        size_t pos = 0;
        while ((pos = content.find(token, pos)) != std::string::npos) {
            count++;
            pos++;
        }
        return count;
    };
 
    std::ifstream f1(filename_default);
    std::string content1((std::istreambuf_iterator<char>(f1)), std::istreambuf_iterator<char>());
    f1.close();
 
    std::ifstream f2(filename_strict);
    std::string content2((std::istreambuf_iterator<char>(f2)), std::istreambuf_iterator<char>());
    f2.close();
 
    size_t links_default = countOccurrences(content1, "PhysicsRigidBodyAPI");
    size_t links_strict = countOccurrences(content2, "PhysicsRigidBodyAPI");
 
    // Stricter filtering should produce fewer or equal links
    DOCTEST_CHECK(links_strict <= links_default);
 
    std::remove(filename_default.c_str());
    std::remove(filename_strict.c_str());
}
 
DOCTEST_TEST_CASE("Growth frame registration") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(plantID) == 0);
 
    // Register a frame at initial state
    plantarchitecture.registerGrowthFrame(plantID);
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(plantID) == 1);
 
    // Advance time and register more frames
    plantarchitecture.advanceTime(10);
    plantarchitecture.registerGrowthFrame(plantID);
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(plantID) == 2);
 
    plantarchitecture.advanceTime(10);
    plantarchitecture.registerGrowthFrame(plantID);
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(plantID) == 3);
 
    // Clear frames
    plantarchitecture.clearGrowthFrames(plantID);
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(plantID) == 0);
 
    // Query for non-existent plant returns 0
    DOCTEST_CHECK(plantarchitecture.getGrowthFrameCount(9999) == 0);
}
 
DOCTEST_TEST_CASE("Growth USD export basic") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
 
    for (int i = 0; i < 3; i++) {
        plantarchitecture.advanceTime(10);
        plantarchitecture.registerGrowthFrame(plantID);
    }
 
    std::string filename = "test_growth_usd.usda";
    // 1 second per growth frame -> time codes spaced by 24 (at 24fps)
    plantarchitecture.writePlantGrowthUSD(plantID, filename, 1.0f);
 
    // Read file and verify key USD attributes
    std::ifstream f(filename);
    DOCTEST_CHECK(f.is_open());
    std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    f.close();
 
    // Verify header fields
    // 3 frames at 1 sec/frame with 24fps -> time codes 0, 24, 48 -> endTimeCode = 48
    DOCTEST_CHECK(content.find("startTimeCode = 0") != std::string::npos);
    DOCTEST_CHECK(content.find("endTimeCode = 48") != std::string::npos);
    DOCTEST_CHECK(content.find("timeCodesPerSecond = 24") != std::string::npos);
    DOCTEST_CHECK(content.find("framesPerSecond = 24") != std::string::npos);
    DOCTEST_CHECK(content.find("upAxis = \"Z\"") != std::string::npos);
 
    // Verify time-sampled transforms exist
    DOCTEST_CHECK(content.find("xformOp:translate.timeSamples") != std::string::npos);
    DOCTEST_CHECK(content.find("xformOp:orient.timeSamples") != std::string::npos);
    DOCTEST_CHECK(content.find("visibility.timeSamples") != std::string::npos);
 
    // Verify no physics prims are present
    DOCTEST_CHECK(content.find("PhysicsArticulationRootAPI") == std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsRigidBodyAPI") == std::string::npos);
    DOCTEST_CHECK(content.find("PhysicsJoint") == std::string::npos);
 
    // Verify mesh data is present
    DOCTEST_CHECK(content.find("def Mesh \"Visual\"") != std::string::npos);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("Growth USD export visibility toggling") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
    plantarchitecture.loadPlantModelFromLibrary("bean");
 
    // Build a very young plant so new organs appear during growth
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 1);
    plantarchitecture.registerGrowthFrame(plantID);
 
    // Advance significantly so new phytomers/organs appear
    plantarchitecture.advanceTime(30);
    plantarchitecture.registerGrowthFrame(plantID);
 
    std::string filename = "test_growth_visibility.usda";
    plantarchitecture.writePlantGrowthUSD(plantID, filename);
 
    std::ifstream f(filename);
    DOCTEST_CHECK(f.is_open());
    std::string content((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    f.close();
 
    // Organs that appeared in frame 2 but not frame 1 should have "invisible" at time 0
    // and "inherited" at time 1. Both tokens should be present somewhere in the file.
    DOCTEST_CHECK(content.find("\"invisible\"") != std::string::npos);
    DOCTEST_CHECK(content.find("\"inherited\"") != std::string::npos);
 
    std::remove(filename.c_str());
}
 
DOCTEST_TEST_CASE("Growth USD export error handling") {
    Context context;
    PlantArchitecture plantarchitecture(&context);
    plantarchitecture.disableMessages();
 
    // Error: invalid plant ID for registerGrowthFrame
    bool threw = false;
    try {
        plantarchitecture.registerGrowthFrame(9999);
    } catch (...) {
        threw = true;
    }
    DOCTEST_CHECK(threw);
 
    // Error: writePlantGrowthUSD with no frames registered
    plantarchitecture.loadPlantModelFromLibrary("bean");
    uint plantID = plantarchitecture.buildPlantInstanceFromLibrary(make_vec3(0, 0, 0), 500);
    threw = false;
    try {
        plantarchitecture.writePlantGrowthUSD(plantID, "test_no_frames.usda");
    } catch (...) {
        threw = true;
    }
    DOCTEST_CHECK(threw);
}
 
int PlantArchitecture::selfTest(int argc, char **argv) {
    return helios::runDoctestWithValidation(argc, argv);
}