Other class is not mocked as required #747

[Markoutte]

Description

Adds mocks for values that are passed into a method by fuzzer. Note, that fuzzer cannot mock any internal values if they are met in the code block.

Fixes #747

Type of Change

• Bug fix (non-breaking change which fixes an issue)

How Has This Been Tested?

Automated Testing

org.utbot.framework.plugin.api.MockOfObjectModelProviderTest

Manual Scenario

Reproduce examples from the issue.

Checklist:

• The change followed the style guidelines of the UTBot project
• Self-review of the code is passed
• The change contains enough commentaries, particularly in hard-to-understand areas
• New documentation is provided or existed one is altered
• No new warnings
• New tests have been added
• All tests pass locally with my changes

[CaelmBleidd]

LGTM

[CaelmBleidd]

Could you make a data class for these pairs?

[Markoutte]

"Pair" is used as convenient and well-known construction like "key to value". Because this method is used by dsl I'd prefer to keep it this way.

Also, I have some doubt about using data classes for such small pairs. Maybe, typealias is more proper way in these cases?

[CaelmBleidd]

Please, use a named argument here

[CaelmBleidd]

And here (a data class). From a browser, it's not obvious which one is what.

[CaelmBleidd]

Why is it not a part of the constructor?

[CaelmBleidd]

As for me, it is hard to read because of missing spaces. My suggestion is something like:

fun replaceToMock(
    assembleModel: UtModel,
    shouldMock: (ClassId) -> Boolean
): UtModel = with(assembleModel) {
    if (this !is UtAssembleModel) return this

    if (shouldMock(classId)) {
        UtCompositeModel(id, classId, isMock = true).apply {
            modificationsChain.forEach {
                if (it is UtDirectSetFieldModel) {
                    fields[it.fieldId] = replaceToMock(it.fieldModel, shouldMock)
                }

                if (it is UtExecutableCallModel && it.executable is FuzzerMockableMethodId) {
                    (it.executable as FuzzerMockableMethodId).mock().forEach { (executionId, models) ->
                        mocks[executionId] = models.map { p -> replaceToMock(p, shouldMock) }
                    }
                }
            }
        }
    } else {
        val models = modificationsChain.map { call ->
            var mockedStatementModel: UtStatementModel? = null

            if (call is UtDirectSetFieldModel) {
                val mock = replaceToMock(call.fieldModel, shouldMock)

                if (mock != call.fieldModel) {
                    mockedStatementModel = UtDirectSetFieldModel(call.instance, call.fieldId, mock)
                }
            } else if (call is UtExecutableCallModel) {
                val params = call.params.map { m -> replaceToMock(m, shouldMock) }

                if (params != call.params) {
                    mockedStatementModel = UtExecutableCallModel(call.instance, call.executable, params)
                }
            }

            mockedStatementModel ?: call
        }

        with(assembleModel) {
            UtAssembleModel(id, classId, modelName, instantiationCall, origin) { models }
        }
    }
}