Method compareGeometryMutation

source/EngineTests/MutationTests.cpp:264–324

    }

    bool compareGeometryMutation(std::vector<uint8_t> const& expected, std::vector<uint8_t> const& actual)
    {
        if (expected.size() != actual.size()) {
            return false;
        }
        auto expectedGenome = GenomeDescriptionService::get().convertBytesToDescription(expected);
        auto actualGenome = GenomeDescriptionService::get().convertBytesToDescription(actual);
        if (expectedGenome.cells.size() != actualGenome.cells.size()) {
            return false;
        }

        auto createCompareClone = [](CellGenomeDescription const& cell) {
            auto clone = cell;
            clone.referenceAngle = 0;
            clone.numRequiredAdditionalConnections = 0;
            if (clone.getCellFunctionType() == CellFunction_Constructor) {
                auto& constructor = std::get<ConstructorGenomeDescription>(*clone.cellFunction);
                if (!constructor.isMakeGenomeCopy()) {
                    constructor.genome = {};
                }
            }
            if (clone.getCellFunctionType() == CellFunction_Injector) {
                auto& injector = std::get<InjectorGenomeDescription>(*clone.cellFunction);
                if (!injector.isMakeGenomeCopy()) {
                    injector.genome = {};
                }
            }
            return clone;
        };

        for (auto const& [expectedCell, actualCell] : boost::combine(expectedGenome.cells, actualGenome.cells)) {
            if (createCompareClone(expectedCell) != createCompareClone(actualCell)) {
                return false;
            }
            if (expectedCell.getCellFunctionType() == CellFunction_Constructor) {
                auto expectedConstructor = std::get<ConstructorGenomeDescription>(*expectedCell.cellFunction);
                auto actualConstructor = std::get<ConstructorGenomeDescription>(*actualCell.cellFunction);
                if (expectedConstructor.isMakeGenomeCopy() != actualConstructor.isMakeGenomeCopy()) {
                    return false;
                }
                if (!expectedConstructor.isMakeGenomeCopy()) {
                    if (!compareGeometryMutation(expectedConstructor.getGenomeData(), actualConstructor.getGenomeData())) {
                        return false;
                    }
                }
            }
            if (expectedCell.getCellFunctionType() == CellFunction_Injector) {
                auto expectedInjector = std::get<InjectorGenomeDescription>(*expectedCell.cellFunction);
                auto actualInjector = std::get<InjectorGenomeDescription>(*actualCell.cellFunction);
                if (expectedInjector.isMakeGenomeCopy() != actualInjector.isMakeGenomeCopy()) {
                    return false;
                }
                if (!expectedInjector.isMakeGenomeCopy()) {
                    if (!compareGeometryMutation(expectedInjector.getGenomeData(), actualInjector.getGenomeData())) {
                        return false;
                    }
                }
            }