Method compareNeuronDataMutation

source/EngineTests/MutationTests.cpp:210–262

    }

    bool compareNeuronDataMutation(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.header != actualGenome.header) {
            return false;
        }
        if (expectedGenome.cells.size() != actualGenome.cells.size()) {
            return false;
        }

        for (auto const& [expectedCell, actualCell] : boost::combine(expectedGenome.cells, actualGenome.cells)) {
            if (expectedCell.getCellFunctionType() != actualCell.getCellFunctionType()) {
                return false;
            }
            if (expectedCell.getCellFunctionType() != CellFunction_Neuron && expectedCell.getCellFunctionType() != CellFunction_Constructor
                && expectedCell.getCellFunctionType() != CellFunction_Injector && expectedCell != actualCell) {
                return false;
            }
            if (expectedCell.color != actualCell.color) {
                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 (!compareNeuronDataMutation(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 (!compareNeuronDataMutation(expectedInjector.getGenomeData(), actualInjector.getGenomeData())) {
                        return false;
                    }
                }
            }

        }
        return true;
    }

    bool compareGeometryMutation(std::vector<uint8_t> const& expected, std::vector<uint8_t> const& actual)
    {