diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParserTest.kt index c76853fff3..cd1bf41957 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParserTest.kt @@ -6,7 +6,7 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows import org.utbot.taint.parser.constants.* import org.utbot.taint.parser.model.* -import org.utbot.taint.parser.yaml.ConfigurationParseError +import org.utbot.taint.parser.yaml.TaintParseError class TaintAnalysisConfigurationParserTest { @@ -27,7 +27,7 @@ class TaintAnalysisConfigurationParserTest { @Test fun `parse should throw exception on incorrect yaml`() { val incorrectYamlInput = yamlInput.replace(k_not, "net") - assertThrows { + assertThrows { TaintAnalysisConfigurationParser.parse(incorrectYamlInput) } } @@ -72,50 +72,50 @@ class TaintAnalysisConfigurationParserTest { $k_marks: environment """.trimIndent() - private val expectedConfiguration = Configuration( + private val expectedConfiguration = DtoTaintConfiguration( sources = listOf( - Source( - methodFqn = MethodFqn(listOf("java", "lang"), "System", "getenv"), - addTo = TaintEntitiesSet(setOf(ReturnValue)), - marks = TaintMarksSet(setOf(TaintMark("environment"))), - signature = SignatureList(listOf(ArgumentTypeString("java.lang.String"))), - conditions = NoConditions + DtoTaintSource( + methodFqn = DtoMethodFqn(listOf("java", "lang"), "System", "getenv"), + addTo = DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), + marks = DtoTaintMarksSet(setOf(DtoTaintMark("environment"))), + signature = DtoTaintSignatureList(listOf(DtoArgumentTypeString("java.lang.String"))), + conditions = DtoNoTaintConditions ) ), passes = listOf( - Pass( - methodFqn = MethodFqn(listOf("java", "lang"), "String", "concat"), - getFrom = TaintEntitiesSet(setOf(ThisObject)), - addTo = TaintEntitiesSet(setOf(ReturnValue)), - marks = TaintMarksSet(setOf(TaintMark("sensitive-data"))), - signature = AnySignature, - conditions = ConditionsMap(mapOf(ThisObject to NotCondition(ValueCondition(ArgumentValueString(""))))) + DtoTaintPass( + methodFqn = DtoMethodFqn(listOf("java", "lang"), "String", "concat"), + getFrom = DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), + addTo = DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), + marks = DtoTaintMarksSet(setOf(DtoTaintMark("sensitive-data"))), + signature = DtoTaintSignatureAny, + conditions = DtoTaintConditionsMap(mapOf(DtoTaintEntityThis to DtoTaintConditionNot(DtoTaintConditionEqualValue(DtoArgumentValueString(""))))) ), - Pass( - methodFqn = MethodFqn(listOf("java", "lang"), "String", "concat"), - getFrom = TaintEntitiesSet(setOf(MethodArgument(1u))), - addTo = TaintEntitiesSet(setOf(ReturnValue)), - marks = TaintMarksSet(setOf(TaintMark("sensitive-data"))), - signature = AnySignature, - conditions = ConditionsMap(mapOf(MethodArgument(1u) to NotCondition(ValueCondition(ArgumentValueString(""))))) + DtoTaintPass( + methodFqn = DtoMethodFqn(listOf("java", "lang"), "String", "concat"), + getFrom = DtoTaintEntitiesSet(setOf(DtoTaintEntityArgument(1u))), + addTo = DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), + marks = DtoTaintMarksSet(setOf(DtoTaintMark("sensitive-data"))), + signature = DtoTaintSignatureAny, + conditions = DtoTaintConditionsMap(mapOf(DtoTaintEntityArgument(1u) to DtoTaintConditionNot(DtoTaintConditionEqualValue(DtoArgumentValueString(""))))) ) ), cleaners = listOf( - Cleaner( - methodFqn = MethodFqn(listOf("java", "lang"), "String", "isEmpty"), - removeFrom = TaintEntitiesSet(setOf(ThisObject)), - marks = TaintMarksSet(setOf(TaintMark("sql-injection"), TaintMark("xss"))), - signature = AnySignature, - conditions = ConditionsMap(mapOf(ReturnValue to ValueCondition(ArgumentValueBoolean(true)))) + DtoTaintCleaner( + methodFqn = DtoMethodFqn(listOf("java", "lang"), "String", "isEmpty"), + removeFrom = DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), + marks = DtoTaintMarksSet(setOf(DtoTaintMark("sql-injection"), DtoTaintMark("xss"))), + signature = DtoTaintSignatureAny, + conditions = DtoTaintConditionsMap(mapOf(DtoTaintEntityReturn to DtoTaintConditionEqualValue(DtoArgumentValueBoolean(true)))) ) ), sinks = listOf( - Sink( - methodFqn = MethodFqn(listOf("org", "example"), "util", "unsafe"), - check = TaintEntitiesSet(setOf(MethodArgument(2u))), - marks = TaintMarksSet(setOf(TaintMark("environment"))), - signature = SignatureList(argumentTypes = listOf(ArgumentTypeAny, ArgumentTypeString("java.lang.Integer"))), - conditions = ConditionsMap(mapOf(MethodArgument(2u) to ValueCondition(ArgumentValueLong(0L)))) + DtoTaintSink( + methodFqn = DtoMethodFqn(listOf("org", "example"), "util", "unsafe"), + check = DtoTaintEntitiesSet(setOf(DtoTaintEntityArgument(2u))), + marks = DtoTaintMarksSet(setOf(DtoTaintMark("environment"))), + signature = DtoTaintSignatureList(argumentTypes = listOf(DtoArgumentTypeAny, DtoArgumentTypeString("java.lang.Integer"))), + conditions = DtoTaintConditionsMap(mapOf(DtoTaintEntityArgument(2u) to DtoTaintConditionEqualValue(DtoArgumentValueLong(0L)))) ) ) ) diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParserTest.kt index ec0b807126..4b4ac03ccf 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParserTest.kt @@ -73,7 +73,7 @@ class MethodArgumentParserTest { @Test fun `should parse underscore as ArgumentTypeAny`() { val yamlScalar = Yaml.default.parseToYamlNode(k__) - val expectedArgumentType = ArgumentTypeAny + val expectedArgumentType = DtoArgumentTypeAny val actualArgumentType = MethodArgumentParser.parseArgumentType(yamlScalar) assertEquals(expectedArgumentType, actualArgumentType) @@ -82,7 +82,7 @@ class MethodArgumentParserTest { @Test fun `should parse type fqn in brackets`() { val yamlScalar = Yaml.default.parseToYamlNode("${k_lt}double${k_gt}") - val expectedArgumentType = ArgumentTypeString("double") + val expectedArgumentType = DtoArgumentTypeString("double") val actualArgumentType = MethodArgumentParser.parseArgumentType(yamlScalar) assertEquals(expectedArgumentType, actualArgumentType) @@ -92,7 +92,7 @@ class MethodArgumentParserTest { fun `should fail on another yaml type`() { val yamlMap = Yaml.default.parseToYamlNode("type: ${k_lt}double${k_gt}") - assertThrows { + assertThrows { MethodArgumentParser.parseArgumentType(yamlMap) } } @@ -104,7 +104,7 @@ class MethodArgumentParserTest { @Test fun `should parse yaml null as ArgumentValueNull`() { val yamlNull = Yaml.default.parseToYamlNode("null") - val expectedArgumentValue = ArgumentValueNull + val expectedArgumentValue = DtoArgumentValueNull val actualArgumentValue = MethodArgumentParser.parseArgumentValue(yamlNull) assertEquals(expectedArgumentValue, actualArgumentValue) @@ -113,7 +113,7 @@ class MethodArgumentParserTest { @Test fun `should parse boolean yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode("false") - val expectedArgumentValue = ArgumentValueBoolean(false) + val expectedArgumentValue = DtoArgumentValueBoolean(false) val actualArgumentValue = MethodArgumentParser.parseArgumentValue(yamlScalar) assertEquals(expectedArgumentValue, actualArgumentValue) @@ -122,7 +122,7 @@ class MethodArgumentParserTest { @Test fun `should parse long yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode("17") - val expectedArgumentValue = ArgumentValueLong(17L) + val expectedArgumentValue = DtoArgumentValueLong(17L) val actualArgumentValue = MethodArgumentParser.parseArgumentValue(yamlScalar) assertEquals(expectedArgumentValue, actualArgumentValue) @@ -131,7 +131,7 @@ class MethodArgumentParserTest { @Test fun `should parse double yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode("1.2") - val expectedArgumentValue = ArgumentValueDouble(1.2) + val expectedArgumentValue = DtoArgumentValueDouble(1.2) val actualArgumentValue = MethodArgumentParser.parseArgumentValue(yamlScalar) assertEquals(expectedArgumentValue, actualArgumentValue) @@ -140,7 +140,7 @@ class MethodArgumentParserTest { @Test fun `should parse string yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode("some-string") - val expectedArgumentValue = ArgumentValueString("some-string") + val expectedArgumentValue = DtoArgumentValueString("some-string") val actualArgumentValue = MethodArgumentParser.parseArgumentValue(yamlScalar) assertEquals(expectedArgumentValue, actualArgumentValue) @@ -150,7 +150,7 @@ class MethodArgumentParserTest { fun `should fail on another yaml type`() { val yamlList = Yaml.default.parseToYamlNode("[ some-string ]") - assertThrows { + assertThrows { MethodArgumentParser.parseArgumentValue(yamlList) } } diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConditionParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConditionParserTest.kt similarity index 56% rename from utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConditionParserTest.kt rename to utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConditionParserTest.kt index ca7c478c8e..3b6fe6f743 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConditionParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConditionParserTest.kt @@ -9,7 +9,7 @@ import org.junit.jupiter.api.assertThrows import org.utbot.taint.parser.constants.* import org.utbot.taint.parser.model.* -class ConditionParserTest { +class TaintConditionParserTest { @Nested @DisplayName("parseCondition") @@ -17,49 +17,49 @@ class ConditionParserTest { @Test fun `should parse yaml null as ValueCondition`() { val yamlNull = Yaml.default.parseToYamlNode("null") - val expectedCondition = ValueCondition(ArgumentValueNull) + val expectedCondition = DtoTaintConditionEqualValue(DtoArgumentValueNull) - val actualCondition = ConditionParser.parseCondition(yamlNull) + val actualCondition = TaintConditionParser.parseCondition(yamlNull) assertEquals(expectedCondition, actualCondition) } @Test fun `should parse yaml scalar with argument value as ValueCondition`() { val yamlScalar = Yaml.default.parseToYamlNode("some-string") - val expectedCondition = ValueCondition(ArgumentValueString("some-string")) + val expectedCondition = DtoTaintConditionEqualValue(DtoArgumentValueString("some-string")) - val actualCondition = ConditionParser.parseCondition(yamlScalar) + val actualCondition = TaintConditionParser.parseCondition(yamlScalar) assertEquals(expectedCondition, actualCondition) } @Test fun `should parse yaml scalar with argument type as TypeCondition`() { val yamlScalar = Yaml.default.parseToYamlNode("${k_lt}java.lang.Integer${k_gt}") - val expectedCondition = TypeCondition(ArgumentTypeString("java.lang.Integer")) + val expectedCondition = DtoTaintConditionIsType(DtoArgumentTypeString("java.lang.Integer")) - val actualCondition = ConditionParser.parseCondition(yamlScalar) + val actualCondition = TaintConditionParser.parseCondition(yamlScalar) assertEquals(expectedCondition, actualCondition) } @Test fun `should parse yaml list as OrCondition`() { val yamlList = Yaml.default.parseToYamlNode("[ 1, true, ${k_lt}java.lang.Integer${k_gt} ]") - val expectedCondition = OrCondition(listOf( - ValueCondition(ArgumentValueLong(1L)), - ValueCondition(ArgumentValueBoolean(true)), - TypeCondition(ArgumentTypeString("java.lang.Integer")), + val expectedCondition = DtoTaintConditionOr(listOf( + DtoTaintConditionEqualValue(DtoArgumentValueLong(1L)), + DtoTaintConditionEqualValue(DtoArgumentValueBoolean(true)), + DtoTaintConditionIsType(DtoArgumentTypeString("java.lang.Integer")), )) - val actualCondition = ConditionParser.parseCondition(yamlList) + val actualCondition = TaintConditionParser.parseCondition(yamlList) assertEquals(expectedCondition, actualCondition) } @Test fun `should parse yaml map with a key 'not' as NotCondition`() { val yamlMap = Yaml.default.parseToYamlNode("$k_not: ${k_lt}int${k_gt}") - val expectedCondition = NotCondition(TypeCondition(ArgumentTypeString("int"))) + val expectedCondition = DtoTaintConditionNot(DtoTaintConditionIsType(DtoArgumentTypeString("int"))) - val actualCondition = ConditionParser.parseCondition(yamlMap) + val actualCondition = TaintConditionParser.parseCondition(yamlMap) assertEquals(expectedCondition, actualCondition) } @@ -67,8 +67,8 @@ class ConditionParserTest { fun `should fail on yaml map without a key 'not'`() { val yamlMap = Yaml.default.parseToYamlNode("net: ${k_lt}int${k_gt}") - assertThrows { - ConditionParser.parseCondition(yamlMap) + assertThrows { + TaintConditionParser.parseCondition(yamlMap) } } @@ -76,21 +76,21 @@ class ConditionParserTest { fun `should fail on yaml map with unknown keys`() { val yamlMap = Yaml.default.parseToYamlNode("{ $k_not: ${k_lt}int${k_gt}, unknown-key: 0 }") - assertThrows { - ConditionParser.parseCondition(yamlMap) + assertThrows { + TaintConditionParser.parseCondition(yamlMap) } } @Test fun `should parse complicated yaml node`() { val yamlMap = Yaml.default.parseToYamlNode("$k_not: [ { $k_not: 0 }, ${k_lt}int${k_gt}, { $k_not: null } ]") - val expectedCondition = NotCondition(OrCondition(listOf( - NotCondition(ValueCondition(ArgumentValueLong(0L))), - TypeCondition(ArgumentTypeString("int")), - NotCondition(ValueCondition(ArgumentValueNull)) + val expectedCondition = DtoTaintConditionNot(DtoTaintConditionOr(listOf( + DtoTaintConditionNot(DtoTaintConditionEqualValue(DtoArgumentValueLong(0L))), + DtoTaintConditionIsType(DtoArgumentTypeString("int")), + DtoTaintConditionNot(DtoTaintConditionEqualValue(DtoArgumentValueNull)) ))) - val actualCondition = ConditionParser.parseCondition(yamlMap) + val actualCondition = TaintConditionParser.parseCondition(yamlMap) assertEquals(expectedCondition, actualCondition) } @@ -98,8 +98,8 @@ class ConditionParserTest { fun `should fail on another yaml type`() { val yamlTaggedNode = YamlTaggedNode("some-tag", YamlNull(YamlPath.root)) - assertThrows { - ConditionParser.parseCondition(yamlTaggedNode) + assertThrows { + TaintConditionParser.parseCondition(yamlTaggedNode) } } } @@ -110,22 +110,22 @@ class ConditionParserTest { @Test fun `should parse correct yaml map as Conditions`() { val yamlMap = Yaml.default.parseToYamlNode("{ $k_this: \"\", ${k_arg}2: { $k_not: ${k_lt}int${k_gt} }, $k_return: [ 0, 1 ] }") - val expectedConditions = ConditionsMap(mapOf( - ThisObject to ValueCondition(ArgumentValueString("")), - MethodArgument(2u) to NotCondition(TypeCondition(ArgumentTypeString("int"))), - ReturnValue to OrCondition(listOf(ValueCondition(ArgumentValueLong(0L)), ValueCondition(ArgumentValueLong(1L)))) + val expectedConditions = DtoTaintConditionsMap(mapOf( + DtoTaintEntityThis to DtoTaintConditionEqualValue(DtoArgumentValueString("")), + DtoTaintEntityArgument(2u) to DtoTaintConditionNot(DtoTaintConditionIsType(DtoArgumentTypeString("int"))), + DtoTaintEntityReturn to DtoTaintConditionOr(listOf(DtoTaintConditionEqualValue(DtoArgumentValueLong(0L)), DtoTaintConditionEqualValue(DtoArgumentValueLong(1L)))) )) - val actualConditions = ConditionParser.parseConditions(yamlMap) + val actualConditions = TaintConditionParser.parseConditions(yamlMap) assertEquals(expectedConditions, actualConditions) } @Test fun `should parse empty yaml map as NoConditions`() { val yamlMap = Yaml.default.parseToYamlNode("{}") - val expectedConditions = NoConditions + val expectedConditions = DtoNoTaintConditions - val actualConditions = ConditionParser.parseConditions(yamlMap) + val actualConditions = TaintConditionParser.parseConditions(yamlMap) assertEquals(expectedConditions, actualConditions) } @@ -133,8 +133,8 @@ class ConditionParserTest { fun `should fail on another yaml type`() { val yamlList = Yaml.default.parseToYamlNode("[]") - assertThrows { - ConditionParser.parseConditions(yamlList) + assertThrows { + TaintConditionParser.parseConditions(yamlList) } } } @@ -145,18 +145,18 @@ class ConditionParserTest { @Test fun `should parse yaml map with a key 'conditions'`() { val yamlMap = Yaml.default.parseToYamlNode("$k_conditions: { $k_return: null }").yamlMap - val expectedConditions = ConditionsMap(mapOf(ReturnValue to ValueCondition(ArgumentValueNull))) + val expectedConditions = DtoTaintConditionsMap(mapOf(DtoTaintEntityReturn to DtoTaintConditionEqualValue(DtoArgumentValueNull))) - val actualConditions = ConditionParser.parseConditionsKey(yamlMap) + val actualConditions = TaintConditionParser.parseConditionsKey(yamlMap) assertEquals(expectedConditions, actualConditions) } @Test fun `should parse yaml map without a key 'conditions' as NoConditions`() { val yamlMap = Yaml.default.parseToYamlNode("$k_marks: []").yamlMap - val expectedConditions = NoConditions + val expectedConditions = DtoNoTaintConditions - val actualConditions = ConditionParser.parseConditionsKey(yamlMap) + val actualConditions = TaintConditionParser.parseConditionsKey(yamlMap) assertEquals(expectedConditions, actualConditions) } } diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConfigurationParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParserTest.kt similarity index 68% rename from utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConfigurationParserTest.kt rename to utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParserTest.kt index 2c15c7e185..312012f6ec 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/ConfigurationParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParserTest.kt @@ -9,7 +9,7 @@ import org.utbot.taint.parser.constants.* import org.utbot.taint.parser.model.* import org.junit.jupiter.api.assertThrows -class ConfigurationParserTest { +class TaintConfigurationParserTest { @Nested @DisplayName("parseConfiguration") @@ -17,18 +17,18 @@ class ConfigurationParserTest { @Test fun `should parse yaml map as Configuration`() { val yamlMap = Yaml.default.parseToYamlNode("{ $k_sources: [], $k_passes: [], $k_cleaners: [], $k_sinks: [] }") - val expectedConfiguration = Configuration(listOf(), listOf(), listOf(), listOf()) + val expectedConfiguration = DtoTaintConfiguration(listOf(), listOf(), listOf(), listOf()) - val actualConfiguration = ConfigurationParser.parseConfiguration(yamlMap) + val actualConfiguration = TaintConfigurationParser.parseConfiguration(yamlMap) assertEquals(expectedConfiguration, actualConfiguration) } @Test fun `should not fail if yaml map does not contain some keys`() { val yamlMap = Yaml.default.parseToYamlNode("{ $k_sources: [], $k_sinks: [] }") - val expectedConfiguration = Configuration(listOf(), listOf(), listOf(), listOf()) + val expectedConfiguration = DtoTaintConfiguration(listOf(), listOf(), listOf(), listOf()) - val actualConfiguration = ConfigurationParser.parseConfiguration(yamlMap) + val actualConfiguration = TaintConfigurationParser.parseConfiguration(yamlMap) assertEquals(expectedConfiguration, actualConfiguration) } @@ -36,8 +36,8 @@ class ConfigurationParserTest { fun `should fail on other yaml types`() { val yamlList = Yaml.default.parseToYamlNode("[]") - assertThrows { - ConfigurationParser.parseConfiguration(yamlList) + assertThrows { + TaintConfigurationParser.parseConfiguration(yamlList) } } @@ -47,8 +47,8 @@ class ConfigurationParserTest { "{ $k_sources: [], $k_passes: [], $k_cleaners: [], $k_sinks: [], unknown-key: [] }" ) - assertThrows { - ConfigurationParser.parseConfiguration(yamlMap) + assertThrows { + TaintConfigurationParser.parseConfiguration(yamlMap) } } } diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintEntityParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintEntityParserTest.kt index 30a4d9d0bb..2ec8fa2522 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintEntityParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintEntityParserTest.kt @@ -17,41 +17,41 @@ class TaintEntityParserTest { @Test fun `should return ThisObject on 'this'`() { val actualEntity = TaintEntityParser.taintEntityByName(k_this) - val expectedEntity = ThisObject + val expectedEntity = DtoTaintEntityThis assertEquals(expectedEntity, actualEntity) } @Test fun `should return ReturnValue on 'return'`() { val actualEntity = TaintEntityParser.taintEntityByName(k_return) - val expectedEntity = ReturnValue + val expectedEntity = DtoTaintEntityReturn assertEquals(expectedEntity, actualEntity) } @Test fun `should return MethodArgument(1) on 'arg1'`() { val actualEntity = TaintEntityParser.taintEntityByName("${k_arg}1") - val expectedEntity = MethodArgument(1u) + val expectedEntity = DtoTaintEntityArgument(1u) assertEquals(expectedEntity, actualEntity) } @Test fun `should return MethodArgument(227) on 'arg227'`() { val actualEntity = TaintEntityParser.taintEntityByName("${k_arg}227") - val expectedEntity = MethodArgument(227u) + val expectedEntity = DtoTaintEntityArgument(227u) assertEquals(expectedEntity, actualEntity) } @Test fun `should fail on zero index 'arg0'`() { - assertThrows { + assertThrows { TaintEntityParser.taintEntityByName("${k_arg}0") } } @Test fun `should fail on another entity name`() { - assertThrows { + assertThrows { TaintEntityParser.taintEntityByName("argument1") } } @@ -63,7 +63,7 @@ class TaintEntityParserTest { @Test fun `should parse yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode(k_this) - val expectedEntities = TaintEntitiesSet(setOf(ThisObject)) + val expectedEntities = DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)) val actualEntities = TaintEntityParser.parseTaintEntities(yamlScalar) assertEquals(expectedEntities, actualEntities) @@ -72,7 +72,7 @@ class TaintEntityParserTest { @Test fun `should parse yaml list`() { val yamlList = Yaml.default.parseToYamlNode("[ $k_this, ${k_arg}1, ${k_arg}5, $k_return ]") - val expectedEntities = TaintEntitiesSet(setOf(ThisObject, MethodArgument(1u), MethodArgument(5u), ReturnValue)) + val expectedEntities = DtoTaintEntitiesSet(setOf(DtoTaintEntityThis, DtoTaintEntityArgument(1u), DtoTaintEntityArgument(5u), DtoTaintEntityReturn)) val actualEntities = TaintEntityParser.parseTaintEntities(yamlList) assertEquals(expectedEntities, actualEntities) @@ -82,7 +82,7 @@ class TaintEntityParserTest { fun `should fail on empty yaml list`() { val yamlListEmpty = Yaml.default.parseToYamlNode("[]") - assertThrows { + assertThrows { TaintEntityParser.parseTaintEntities(yamlListEmpty) } } @@ -91,7 +91,7 @@ class TaintEntityParserTest { fun `should fail on another yaml type`() { val yamlMap = Yaml.default.parseToYamlNode("$k_addTo: $k_return") - assertThrows { + assertThrows { TaintEntityParser.parseTaintEntities(yamlMap) } } diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintMarkParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintMarkParserTest.kt index 6ed31e508f..42218038d8 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintMarkParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintMarkParserTest.kt @@ -17,7 +17,7 @@ class TaintMarkParserTest { @Test fun `should parse yaml scalar`() { val yamlScalar = Yaml.default.parseToYamlNode("sensitive-data") - val expectedMarks = TaintMarksSet(setOf(TaintMark("sensitive-data"))) + val expectedMarks = DtoTaintMarksSet(setOf(DtoTaintMark("sensitive-data"))) val actualMarks = TaintMarkParser.parseTaintMarks(yamlScalar) assertEquals(expectedMarks, actualMarks) @@ -27,7 +27,7 @@ class TaintMarkParserTest { fun `should parse yaml list`() { val yamlList = Yaml.default.parseToYamlNode("[ xss, sensitive-data, sql-injection ]") val expectedMarks = - TaintMarksSet(setOf(TaintMark("xss"), TaintMark("sensitive-data"), TaintMark("sql-injection"))) + DtoTaintMarksSet(setOf(DtoTaintMark("xss"), DtoTaintMark("sensitive-data"), DtoTaintMark("sql-injection"))) val actualMarks = TaintMarkParser.parseTaintMarks(yamlList) assertEquals(expectedMarks, actualMarks) @@ -36,7 +36,7 @@ class TaintMarkParserTest { @Test fun `should parse empty yaml list`() { val yamlListEmpty = Yaml.default.parseToYamlNode("[]") - val expectedMarks = AllTaintMarks + val expectedMarks = DtoTaintMarksAll val actualMarks = TaintMarkParser.parseTaintMarks(yamlListEmpty) assertEquals(expectedMarks, actualMarks) @@ -46,7 +46,7 @@ class TaintMarkParserTest { fun `should fail on another yaml type`() { val yamlMap = Yaml.default.parseToYamlNode("$k_marks: [ xss ]") - assertThrows { + assertThrows { TaintMarkParser.parseTaintMarks(yamlMap) } } diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/RuleParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintRuleParserTest.kt similarity index 67% rename from utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/RuleParserTest.kt rename to utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintRuleParserTest.kt index b30b4950c7..5d9dba1115 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/RuleParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintRuleParserTest.kt @@ -6,17 +6,17 @@ import org.junit.jupiter.api.Assertions.* import org.utbot.taint.parser.constants.* import org.utbot.taint.parser.model.* -class RuleParserTest { +class TaintRuleParserTest { @Nested @DisplayName("isRule") inner class IsRuleTest { private val isRuleData = listOf( - SourceData to RuleParser::isSourceRule, - PassData to RuleParser::isPassRule, - CleanerData to RuleParser::isCleanerRule, - SinkData to RuleParser::isSinkRule + SourceData to TaintRuleParser::isSourceRule, + PassData to TaintRuleParser::isPassRule, + CleanerData to TaintRuleParser::isCleanerRule, + SinkData to TaintRuleParser::isSinkRule ) @TestFactory @@ -58,10 +58,10 @@ class RuleParserTest { inner class ParseRuleTest { private val parseRuleData = listOf( - SourceData to RuleParser::parseSourceRule, - PassData to RuleParser::parsePassRule, - CleanerData to RuleParser::parseCleanerRule, - SinkData to RuleParser::parseSinkRule + SourceData to TaintRuleParser::parseSourceRule, + PassData to TaintRuleParser::parsePassRule, + CleanerData to TaintRuleParser::parseCleanerRule, + SinkData to TaintRuleParser::parseSinkRule ) @TestFactory @@ -91,7 +91,7 @@ class RuleParserTest { DynamicTest.dynamicTest(parseRule.name) { val yamlMap = Yaml.default.parseToYamlNode(ruleData.yamlInputUnknownKey) - assertThrows { + assertThrows { parseRule(yamlMap, defaultMethodNameParts) } } @@ -103,10 +103,10 @@ class RuleParserTest { inner class ParseSourcesTest { private val parseRulesData = listOf( - SourcesData to RuleParser::parseSources, - PassesData to RuleParser::parsePasses, - CleanersData to RuleParser::parseCleaners, - SinksData to RuleParser::parseSinks + SourcesData to TaintRuleParser::parseSources, + PassesData to TaintRuleParser::parsePasses, + CleanersData to TaintRuleParser::parseCleaners, + SinksData to TaintRuleParser::parseSinks ) @TestFactory @@ -136,7 +136,7 @@ class RuleParserTest { DynamicTest.dynamicTest(parseRules.name) { val yamlMap = Yaml.default.parseToYamlNode(rulesData.yamlInputInvalid) - assertThrows { + assertThrows { parseRules(yamlMap) } } @@ -146,7 +146,7 @@ class RuleParserTest { // test data private val defaultMethodNameParts = listOf("org.example.Server.start") - private val defaultMethodFqn = MethodFqn(listOf("org", "example"), "Server", "start") + private val defaultMethodFqn = DtoMethodFqn(listOf("org", "example"), "Server", "start") // one rule @@ -156,68 +156,68 @@ class RuleParserTest { val yamlInputInvalid: String val yamlInputUnknownKey: String - fun yamlInputParsed(methodFqn: MethodFqn): Rule - fun yamlInputAdvancedParsed(methodFqn: MethodFqn): Rule + fun yamlInputParsed(methodFqn: DtoMethodFqn): Rule + fun yamlInputAdvancedParsed(methodFqn: DtoMethodFqn): Rule } - private object SourceData : RuleData { + private object SourceData : RuleData { override val yamlInput = "{ $k_addTo: $k_return, $k_marks: [] }" override val yamlInputAdvanced = "{ $k_signature: [], $k_conditions: {}, $k_addTo: $k_return, $k_marks: [] }" override val yamlInputInvalid = "{ invalid-key: $k_return, $k_marks: [] }" override val yamlInputUnknownKey = "{ $k_addTo: $k_return, $k_marks: [], unknown-key: [] }" - override fun yamlInputParsed(methodFqn: MethodFqn) = - Source(methodFqn, TaintEntitiesSet(setOf(ReturnValue)), AllTaintMarks) + override fun yamlInputParsed(methodFqn: DtoMethodFqn) = + DtoTaintSource(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), DtoTaintMarksAll) - override fun yamlInputAdvancedParsed(methodFqn: MethodFqn) = - Source(methodFqn, TaintEntitiesSet(setOf(ReturnValue)), AllTaintMarks, SignatureList(listOf()), NoConditions) + override fun yamlInputAdvancedParsed(methodFqn: DtoMethodFqn) = + DtoTaintSource(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), DtoTaintMarksAll, DtoTaintSignatureList(listOf()), DtoNoTaintConditions) } - private object PassData : RuleData { + private object PassData : RuleData { override val yamlInput = "{ $k_getFrom: $k_this, $k_addTo: $k_return, $k_marks: [] }" override val yamlInputAdvanced = "{ $k_signature: [], $k_conditions: {}, $k_getFrom: $k_this, $k_addTo: $k_return, $k_marks: [] }" override val yamlInputInvalid = "{ $k_getFrom: $k_this, $k_addTo: $k_return, invalid-key: [] }" override val yamlInputUnknownKey = "{ $k_getFrom: $k_this, $k_addTo: $k_return, $k_marks: [], unknown-key: [] }" - override fun yamlInputParsed(methodFqn: MethodFqn) = - Pass(methodFqn, TaintEntitiesSet(setOf(ThisObject)), TaintEntitiesSet(setOf(ReturnValue)), AllTaintMarks) + override fun yamlInputParsed(methodFqn: DtoMethodFqn) = + DtoTaintPass(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), DtoTaintMarksAll) - override fun yamlInputAdvancedParsed(methodFqn: MethodFqn) = - Pass(methodFqn, TaintEntitiesSet(setOf(ThisObject)), TaintEntitiesSet(setOf(ReturnValue)), AllTaintMarks, SignatureList(listOf()), NoConditions) + override fun yamlInputAdvancedParsed(methodFqn: DtoMethodFqn) = + DtoTaintPass(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintEntitiesSet(setOf(DtoTaintEntityReturn)), DtoTaintMarksAll, DtoTaintSignatureList(listOf()), DtoNoTaintConditions) } - private object CleanerData : RuleData { + private object CleanerData : RuleData { override val yamlInput = "{ $k_removeFrom: $k_this, $k_marks: [] }" override val yamlInputAdvanced = "{ $k_signature: [], $k_conditions: {}, $k_removeFrom: $k_this, $k_marks: [] }" override val yamlInputInvalid = "{ $k_removeFrom: $k_this, invalid-key: [] }" override val yamlInputUnknownKey = "{ $k_removeFrom: $k_this, $k_marks: [], unknown-key: [] }" - override fun yamlInputParsed(methodFqn: MethodFqn) = - Cleaner(methodFqn, TaintEntitiesSet(setOf(ThisObject)), AllTaintMarks) + override fun yamlInputParsed(methodFqn: DtoMethodFqn) = + DtoTaintCleaner(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintMarksAll) - override fun yamlInputAdvancedParsed(methodFqn: MethodFqn) = - Cleaner(methodFqn, TaintEntitiesSet(setOf(ThisObject)), AllTaintMarks, SignatureList(listOf()), NoConditions) + override fun yamlInputAdvancedParsed(methodFqn: DtoMethodFqn) = + DtoTaintCleaner(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintMarksAll, DtoTaintSignatureList(listOf()), DtoNoTaintConditions) } - private object SinkData : RuleData { + private object SinkData : RuleData { override val yamlInput = "{ $k_check: $k_this, $k_marks: [] }" override val yamlInputAdvanced = "{ $k_signature: [], $k_conditions: {}, $k_check: $k_this, $k_marks: [] }" override val yamlInputInvalid = "{ $k_check: $k_this, invalid-key: [] }" override val yamlInputUnknownKey = "{ $k_check: $k_this, $k_marks: [], unknown-key: [] }" - override fun yamlInputParsed(methodFqn: MethodFqn) = - Sink(methodFqn, TaintEntitiesSet(setOf(ThisObject)), AllTaintMarks) + override fun yamlInputParsed(methodFqn: DtoMethodFqn) = + DtoTaintSink(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintMarksAll) - override fun yamlInputAdvancedParsed(methodFqn: MethodFqn) = - Sink(methodFqn, TaintEntitiesSet(setOf(ThisObject)), AllTaintMarks, SignatureList(listOf()), NoConditions) + override fun yamlInputAdvancedParsed(methodFqn: DtoMethodFqn) = + DtoTaintSink(methodFqn, DtoTaintEntitiesSet(setOf(DtoTaintEntityThis)), DtoTaintMarksAll, DtoTaintSignatureList(listOf()), DtoNoTaintConditions) } // combined rules - private object SourcesData : RulesData(SourceData) - private object PassesData : RulesData(PassData) - private object CleanersData : RulesData(CleanerData) - private object SinksData : RulesData(SinkData) + private object SourcesData : RulesData(SourceData) + private object PassesData : RulesData(PassData) + private object CleanersData : RulesData(CleanerData) + private object SinksData : RulesData(SinkData) private open class RulesData(ruleData: RuleData) { val yamlInput = """ @@ -242,15 +242,15 @@ class RuleParserTest { """.trimIndent() val yamlInputParsed = listOf( - ruleData.yamlInputParsed(MethodFqn(listOf("a", "b"), "c", "m")), - ruleData.yamlInputAdvancedParsed(MethodFqn(listOf("d", "e"), "f", "m")) + ruleData.yamlInputParsed(DtoMethodFqn(listOf("a", "b"), "c", "m")), + ruleData.yamlInputAdvancedParsed(DtoMethodFqn(listOf("d", "e"), "f", "m")) ) val yamlInputNestedNamesParsed = listOf( - ruleData.yamlInputParsed(MethodFqn(listOf("a", "b"), "c", "m")), - ruleData.yamlInputAdvancedParsed(MethodFqn(listOf("a", "b"), "c", "m")), - ruleData.yamlInputParsed(MethodFqn(listOf("a", "d"), "e", "m1")), - ruleData.yamlInputAdvancedParsed(MethodFqn(listOf("a", "d"), "e", "m2")) + ruleData.yamlInputParsed(DtoMethodFqn(listOf("a", "b"), "c", "m")), + ruleData.yamlInputAdvancedParsed(DtoMethodFqn(listOf("a", "b"), "c", "m")), + ruleData.yamlInputParsed(DtoMethodFqn(listOf("a", "d"), "e", "m1")), + ruleData.yamlInputAdvancedParsed(DtoMethodFqn(listOf("a", "d"), "e", "m2")) ) } } \ No newline at end of file diff --git a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/SignatureParserTest.kt b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParserTest.kt similarity index 65% rename from utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/SignatureParserTest.kt rename to utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParserTest.kt index b235ee9c16..25ec5b7159 100644 --- a/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/SignatureParserTest.kt +++ b/utbot-framework-test/src/test/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParserTest.kt @@ -10,7 +10,7 @@ import org.utbot.taint.parser.constants.* import org.utbot.taint.parser.model.* import org.junit.jupiter.api.assertThrows -class SignatureParserTest { +class TaintSignatureParserTest { @Nested @DisplayName("parseSignatureKey") @@ -18,18 +18,18 @@ class SignatureParserTest { @Test fun `should parse yaml list of the argument types`() { val yamlList = Yaml.default.parseToYamlNode("[ ${k_lt}int${k_gt}, $k__, ${k_lt}java.lang.String${k_gt} ]") - val expectedSignature = SignatureList(listOf(ArgumentTypeString("int"), ArgumentTypeAny, ArgumentTypeString("java.lang.String"))) + val expectedSignature = DtoTaintSignatureList(listOf(DtoArgumentTypeString("int"), DtoArgumentTypeAny, DtoArgumentTypeString("java.lang.String"))) - val actualSignature = SignatureParser.parseSignature(yamlList) + val actualSignature = TaintSignatureParser.parseSignature(yamlList) assertEquals(expectedSignature, actualSignature) } @Test fun `should parse empty yaml list`() { val yamlList = Yaml.default.parseToYamlNode("[]") - val expectedSignature = SignatureList(listOf()) + val expectedSignature = DtoTaintSignatureList(listOf()) - val actualSignature = SignatureParser.parseSignature(yamlList) + val actualSignature = TaintSignatureParser.parseSignature(yamlList) assertEquals(expectedSignature, actualSignature) } @@ -37,8 +37,8 @@ class SignatureParserTest { fun `should fail on incorrect signature`() { val yamlList = Yaml.default.parseToYamlNode("[ 0, $k__, 2 ]") - assertThrows { - SignatureParser.parseSignature(yamlList) + assertThrows { + TaintSignatureParser.parseSignature(yamlList) } } @@ -46,8 +46,8 @@ class SignatureParserTest { fun `should fail on another yaml type`() { val yamlMap = Yaml.default.parseToYamlNode("$k_signature: []") - assertThrows { - SignatureParser.parseSignature(yamlMap) + assertThrows { + TaintSignatureParser.parseSignature(yamlMap) } } } @@ -58,18 +58,18 @@ class SignatureParserTest { @Test fun `should parse yaml map with a key 'signature'`() { val yamlList = Yaml.default.parseToYamlNode("$k_signature: [ $k__, $k__, ${k_lt}int${k_gt} ]").yamlMap - val expectedSignature = SignatureList(listOf(ArgumentTypeAny, ArgumentTypeAny, ArgumentTypeString("int"))) + val expectedSignature = DtoTaintSignatureList(listOf(DtoArgumentTypeAny, DtoArgumentTypeAny, DtoArgumentTypeString("int"))) - val actualSignature = SignatureParser.parseSignatureKey(yamlList) + val actualSignature = TaintSignatureParser.parseSignatureKey(yamlList) assertEquals(expectedSignature, actualSignature) } @Test fun `should parse yaml map without a key 'signature' as AnySignature`() { val yamlMap = Yaml.default.parseToYamlNode("$k_marks: []").yamlMap - val expectedSignature = AnySignature + val expectedSignature = DtoTaintSignatureAny - val actualSignature = SignatureParser.parseSignatureKey(yamlMap) + val actualSignature = TaintSignatureParser.parseSignatureKey(yamlMap) assertEquals(expectedSignature, actualSignature) } } diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParser.kt index 90784c4fb3..fc1795c9d8 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/TaintAnalysisConfigurationParser.kt @@ -2,9 +2,9 @@ package org.utbot.taint.parser import com.charleskorn.kaml.Yaml import com.charleskorn.kaml.YamlException -import org.utbot.taint.parser.model.Configuration -import org.utbot.taint.parser.yaml.ConfigurationParseError -import org.utbot.taint.parser.yaml.ConfigurationParser.parseConfiguration +import org.utbot.taint.parser.model.DtoTaintConfiguration +import org.utbot.taint.parser.yaml.TaintParseError +import org.utbot.taint.parser.yaml.TaintConfigurationParser.parseConfiguration /** * YAML configuration file parser. @@ -14,9 +14,9 @@ object TaintAnalysisConfigurationParser { * Parses the YAML configuration file to our data classes. * * @throws YamlException - * @throws ConfigurationParseError + * @throws TaintParseError */ - fun parse(yamlInput: String): Configuration { + fun parse(yamlInput: String): DtoTaintConfiguration { val rootNode = Yaml.default.parseToYamlNode(yamlInput) return parseConfiguration(rootNode) } diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataClasses.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataClasses.kt deleted file mode 100644 index 1a795770b4..0000000000 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataClasses.kt +++ /dev/null @@ -1,89 +0,0 @@ -package org.utbot.taint.parser.model - -/** - * See "docs/TaintAnalysis.md" for configuration format. - */ -data class Configuration( - val sources: List, - val passes: List, - val cleaners: List, - val sinks: List -) - -data class Source( - val methodFqn: MethodFqn, - val addTo: TaintEntities, - val marks: TaintMarks, - val signature: Signature = AnySignature, - val conditions: Conditions = NoConditions, -) - -data class Pass( - val methodFqn: MethodFqn, - val getFrom: TaintEntities, - val addTo: TaintEntities, - val marks: TaintMarks, - val signature: Signature = AnySignature, - val conditions: Conditions = NoConditions, -) - -data class Cleaner( - val methodFqn: MethodFqn, - val removeFrom: TaintEntities, - val marks: TaintMarks, - val signature: Signature = AnySignature, - val conditions: Conditions = NoConditions, -) - -data class Sink( - val methodFqn: MethodFqn, - val check: TaintEntities, - val marks: TaintMarks, - val signature: Signature = AnySignature, - val conditions: Conditions = NoConditions, -) - -data class MethodFqn( - val packageNames: List, - val className: String, - val methodName: String -) - -sealed interface TaintEntities -data class TaintEntitiesSet(val entities: Set) : TaintEntities - -sealed interface TaintMarks -object AllTaintMarks : TaintMarks -data class TaintMarksSet(val marks: Set) : TaintMarks - -sealed interface Signature -object AnySignature : Signature -data class SignatureList(val argumentTypes: List) : Signature - -sealed interface Conditions -object NoConditions : Conditions -data class ConditionsMap(val entityToCondition: Map) : Conditions - -sealed interface TaintEntity -object ThisObject : TaintEntity -object ReturnValue : TaintEntity -data class MethodArgument(/** one-based */ val index: UInt) : TaintEntity - -data class TaintMark(val name: String) - -sealed interface Condition -data class ValueCondition(val argumentValue: ArgumentValue) : Condition -data class TypeCondition(val argumentType: ArgumentType) : Condition -data class NotCondition(val inner: Condition) : Condition -data class OrCondition(val inners: List) : Condition - -sealed interface ArgumentValue -object ArgumentValueNull : ArgumentValue -data class ArgumentValueBoolean(val value: Boolean) : ArgumentValue -data class ArgumentValueLong(val value: Long) : ArgumentValue -data class ArgumentValueDouble(val value: Double) : ArgumentValue -data class ArgumentValueString(val value: String) : ArgumentValue - -sealed interface ArgumentType -object ArgumentTypeAny : ArgumentType -data class ArgumentTypeString(val typeFqn: String) : ArgumentType diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataTransferObjects.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataTransferObjects.kt new file mode 100644 index 0000000000..c48518120a --- /dev/null +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/model/DataTransferObjects.kt @@ -0,0 +1,89 @@ +package org.utbot.taint.parser.model + +/** + * See "docs/TaintAnalysis.md" for configuration format. + */ +data class DtoTaintConfiguration( + val sources: List, + val passes: List, + val cleaners: List, + val sinks: List +) + +data class DtoTaintSource( + val methodFqn: DtoMethodFqn, + val addTo: DtoTaintEntities, + val marks: DtoTaintMarks, + val signature: DtoTaintSignature = DtoTaintSignatureAny, + val conditions: DtoTaintConditions = DtoNoTaintConditions, +) + +data class DtoTaintPass( + val methodFqn: DtoMethodFqn, + val getFrom: DtoTaintEntities, + val addTo: DtoTaintEntities, + val marks: DtoTaintMarks, + val signature: DtoTaintSignature = DtoTaintSignatureAny, + val conditions: DtoTaintConditions = DtoNoTaintConditions, +) + +data class DtoTaintCleaner( + val methodFqn: DtoMethodFqn, + val removeFrom: DtoTaintEntities, + val marks: DtoTaintMarks, + val signature: DtoTaintSignature = DtoTaintSignatureAny, + val conditions: DtoTaintConditions = DtoNoTaintConditions, +) + +data class DtoTaintSink( + val methodFqn: DtoMethodFqn, + val check: DtoTaintEntities, + val marks: DtoTaintMarks, + val signature: DtoTaintSignature = DtoTaintSignatureAny, + val conditions: DtoTaintConditions = DtoNoTaintConditions, +) + +data class DtoMethodFqn( + val packageNames: List, + val className: String, + val methodName: String +) + +sealed interface DtoTaintEntities +data class DtoTaintEntitiesSet(val entities: Set) : DtoTaintEntities + +sealed interface DtoTaintMarks +object DtoTaintMarksAll : DtoTaintMarks +data class DtoTaintMarksSet(val marks: Set) : DtoTaintMarks + +sealed interface DtoTaintSignature +object DtoTaintSignatureAny : DtoTaintSignature +data class DtoTaintSignatureList(val argumentTypes: List) : DtoTaintSignature + +sealed interface DtoTaintConditions +object DtoNoTaintConditions : DtoTaintConditions +data class DtoTaintConditionsMap(val entityToCondition: Map) : DtoTaintConditions + +sealed interface DtoTaintEntity +object DtoTaintEntityThis : DtoTaintEntity +data class DtoTaintEntityArgument(/** one-based */ val index: UInt) : DtoTaintEntity +object DtoTaintEntityReturn : DtoTaintEntity + +data class DtoTaintMark(val name: String) + +sealed interface DtoTaintCondition +data class DtoTaintConditionEqualValue(val argumentValue: DtoArgumentValue) : DtoTaintCondition +data class DtoTaintConditionIsType(val argumentType: DtoArgumentType) : DtoTaintCondition +data class DtoTaintConditionNot(val inner: DtoTaintCondition) : DtoTaintCondition +data class DtoTaintConditionOr(val inners: List) : DtoTaintCondition + +sealed interface DtoArgumentValue +object DtoArgumentValueNull : DtoArgumentValue +data class DtoArgumentValueBoolean(val value: Boolean) : DtoArgumentValue +data class DtoArgumentValueLong(val value: Long) : DtoArgumentValue +data class DtoArgumentValueDouble(val value: Double) : DtoArgumentValue +data class DtoArgumentValueString(val value: String) : DtoArgumentValue + +sealed interface DtoArgumentType +object DtoArgumentTypeAny : DtoArgumentType +data class DtoArgumentTypeString(val typeFqn: String) : DtoArgumentType diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParser.kt index 7bb60ad2f2..f097708bd7 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/MethodArgumentParser.kt @@ -16,13 +16,13 @@ object MethodArgumentParser { /** * This method is expected to be called only if the [isArgumentType] method returned `true`. */ - fun parseArgumentType(node: YamlNode): ArgumentType { + fun parseArgumentType(node: YamlNode): DtoArgumentType { validate(node is YamlScalar, "The argument type node should be a scalar", node) return when (val typeDescription = node.content) { - ARGUMENT_TYPE_UNDERSCORE -> ArgumentTypeAny + ARGUMENT_TYPE_UNDERSCORE -> DtoArgumentTypeAny else -> { val typeFqn = typeDescription.removeSurrounding(ARGUMENT_TYPE_PREFIX, ARGUMENT_TYPE_SUFFIX) - ArgumentTypeString(typeFqn) + DtoArgumentTypeString(typeFqn) } } } @@ -30,15 +30,15 @@ object MethodArgumentParser { /** * This method is expected to be called only if the [isArgumentValue] method returned `true`. */ - fun parseArgumentValue(node: YamlNode): ArgumentValue { + fun parseArgumentValue(node: YamlNode): DtoArgumentValue { return when (node) { - is YamlNull -> ArgumentValueNull + is YamlNull -> DtoArgumentValueNull is YamlScalar -> { - val conversions: List<(YamlScalar) -> ArgumentValue> = listOf( - { ArgumentValueBoolean(it.toBoolean()) }, - { ArgumentValueLong(it.toLong()) }, - { ArgumentValueDouble(it.toDouble()) }, - { ArgumentValueString(it.content) }, + val conversions: List<(YamlScalar) -> DtoArgumentValue> = listOf( + { DtoArgumentValueBoolean(it.toBoolean()) }, + { DtoArgumentValueLong(it.toLong()) }, + { DtoArgumentValueDouble(it.toDouble()) }, + { DtoArgumentValueString(it.content) }, ) for (conversion in conversions) { @@ -48,16 +48,16 @@ object MethodArgumentParser { continue } } - throw ConfigurationParseError("All conversions failed for the argument value node", node) + throw TaintParseError("All conversions failed for the argument value node", node) } else -> { - throw ConfigurationParseError("The argument value node should be a null or a scalar", node) + throw TaintParseError("The argument value node should be a null or a scalar", node) } } } /** - * Checks that the [node] can be parsed to [ArgumentType]. + * Checks that the [node] can be parsed to [DtoArgumentType]. */ fun isArgumentType(node: YamlNode): Boolean { val content = (node as? YamlScalar)?.content ?: return false @@ -69,7 +69,7 @@ object MethodArgumentParser { } /** - * Checks that the [node] can be parsed to [ArgumentValue]. + * Checks that the [node] can be parsed to [DtoArgumentValue]. */ fun isArgumentValue(node: YamlNode): Boolean = (node is YamlNull) || (node is YamlScalar) && !isArgumentType(node) diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConditionParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConditionParser.kt similarity index 68% rename from utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConditionParser.kt rename to utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConditionParser.kt index d7a5550f98..27b3a4be6d 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConditionParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConditionParser.kt @@ -10,7 +10,7 @@ import org.utbot.taint.parser.yaml.TaintEntityParser.taintEntityByName import kotlin.contracts.ExperimentalContracts @OptIn(ExperimentalContracts::class) -object ConditionParser { +object TaintConditionParser { /** * Expects a [YamlMap] with (or without) a key [Constants.KEY_CONDITIONS]. @@ -25,8 +25,8 @@ object ConditionParser { * return: [ "", { not: } ] * ``` */ - fun parseConditionsKey(ruleMap: YamlMap): Conditions = - ruleMap.get(Constants.KEY_CONDITIONS)?.let(ConditionParser::parseConditions) ?: NoConditions + fun parseConditionsKey(ruleMap: YamlMap): DtoTaintConditions = + ruleMap.get(Constants.KEY_CONDITIONS)?.let(TaintConditionParser::parseConditions) ?: DtoNoTaintConditions /** * Expects a [YamlMap] with taint entities as keys. @@ -40,41 +40,41 @@ object ConditionParser { * return: [ "", { not: } ] * ``` */ - fun parseConditions(node: YamlNode): Conditions { + fun parseConditions(node: YamlNode): DtoTaintConditions { validate(node is YamlMap, "The conditions node should be a map", node) return if (node.entries.isEmpty()) { - NoConditions + DtoNoTaintConditions } else { val entityToCondition = node.entries.map { (taintEntityNameScalar, conditionNode) -> taintEntityByName(taintEntityNameScalar.content) to parseCondition(conditionNode) }.toMap() - ConditionsMap(entityToCondition) + DtoTaintConditionsMap(entityToCondition) } } /** * Expects a [YamlNode] that describes one condition. */ - fun parseCondition(node: YamlNode): Condition = + fun parseCondition(node: YamlNode): DtoTaintCondition = when (node) { // example: `null` is YamlNull -> { - ValueCondition(parseArgumentValue(node)) + DtoTaintConditionEqualValue(parseArgumentValue(node)) } // examples: `227`, `"some string"`, `` is YamlScalar -> { when { - isArgumentType(node) -> TypeCondition(parseArgumentType(node)) - isArgumentValue(node) -> ValueCondition(parseArgumentValue(node)) - else -> throw ConfigurationParseError("The condition scalar should be a type or a value", node) + isArgumentType(node) -> DtoTaintConditionIsType(parseArgumentType(node)) + isArgumentValue(node) -> DtoTaintConditionEqualValue(parseArgumentValue(node)) + else -> throw TaintParseError("The condition scalar should be a type or a value", node) } } // examples: `[ true, 1, "yes" ]`, `[ "", { not: } ]` is YamlList -> { - val innerConditions = node.items.map(ConditionParser::parseCondition) - OrCondition(innerConditions) + val innerConditions = node.items.map(TaintConditionParser::parseCondition) + DtoTaintConditionOr(innerConditions) } // examples: `{ not: null }`, `{ not: [1, 2, 3] }` @@ -82,11 +82,11 @@ object ConditionParser { validateYamlMapKeys(node, setOf(Constants.KEY_CONDITION_NOT)) val innerNode = node.get(Constants.KEY_CONDITION_NOT)!! val innerCondition = parseCondition(innerNode) - NotCondition(innerCondition) + DtoTaintConditionNot(innerCondition) } else -> { - throw ConfigurationParseError("The condition node has an unknown type", node) + throw TaintParseError("The condition node has an unknown type", node) } } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConfigurationParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParser.kt similarity index 66% rename from utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConfigurationParser.kt rename to utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParser.kt index ab9fe6e803..f468cc7079 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/ConfigurationParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintConfigurationParser.kt @@ -2,7 +2,7 @@ package org.utbot.taint.parser.yaml import com.charleskorn.kaml.YamlMap import com.charleskorn.kaml.YamlNode -import org.utbot.taint.parser.model.Configuration +import org.utbot.taint.parser.model.DtoTaintConfiguration import org.utbot.taint.parser.yaml.Constants.KEY_CLEANERS import org.utbot.taint.parser.yaml.Constants.KEY_PASSES import org.utbot.taint.parser.yaml.Constants.KEY_SINKS @@ -10,7 +10,7 @@ import org.utbot.taint.parser.yaml.Constants.KEY_SOURCES import kotlin.contracts.ExperimentalContracts @OptIn(ExperimentalContracts::class) -object ConfigurationParser { +object TaintConfigurationParser { /** * Expects a [YamlMap] with keys [KEY_SOURCES], [KEY_PASSES], [KEY_CLEANERS] and [KEY_SINKS]. @@ -24,7 +24,7 @@ object ConfigurationParser { * sinks: [ ... ] * ``` */ - fun parseConfiguration(node: YamlNode): Configuration { + fun parseConfiguration(node: YamlNode): DtoTaintConfiguration { validate(node is YamlMap, "The root node should be a map", node) validateYamlMapKeys(node, setOf(KEY_SOURCES, KEY_PASSES, KEY_CLEANERS, KEY_SINKS)) @@ -33,11 +33,11 @@ object ConfigurationParser { val cleanersNode = node.get(KEY_CLEANERS) val sinksNode = node.get(KEY_SINKS) - val sources = sourcesNode?.let(RuleParser::parseSources) ?: listOf() - val passes = passesNode?.let(RuleParser::parsePasses) ?: listOf() - val cleaners = cleanersNode?.let(RuleParser::parseCleaners) ?: listOf() - val sinks = sinksNode?.let(RuleParser::parseSinks) ?: listOf() + val sources = sourcesNode?.let(TaintRuleParser::parseSources) ?: listOf() + val passes = passesNode?.let(TaintRuleParser::parsePasses) ?: listOf() + val cleaners = cleanersNode?.let(TaintRuleParser::parseCleaners) ?: listOf() + val sinks = sinksNode?.let(TaintRuleParser::parseSinks) ?: listOf() - return Configuration(sources, passes, cleaners, sinks) + return DtoTaintConfiguration(sources, passes, cleaners, sinks) } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintEntityParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintEntityParser.kt index 45cc8ad815..0c36bfa229 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintEntityParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintEntityParser.kt @@ -16,10 +16,10 @@ object TaintEntityParser { * * `[ this, arg1, arg7, return ]` */ - fun parseTaintEntities(node: YamlNode): TaintEntities = + fun parseTaintEntities(node: YamlNode): DtoTaintEntities = when (node) { is YamlScalar -> { - TaintEntitiesSet(setOf(taintEntityByName(node.content))) + DtoTaintEntitiesSet(setOf(taintEntityByName(node.content))) } is YamlList -> { validate(node.items.isNotEmpty(), "The taint entities set should contain at least one value", node) @@ -27,25 +27,25 @@ object TaintEntityParser { validate(innerNode is YamlScalar, "The taint entity name should be a scalar", node) taintEntityByName(innerNode.content) } - TaintEntitiesSet(entities.toSet()) + DtoTaintEntitiesSet(entities.toSet()) } else -> { - throw ConfigurationParseError("The taint-entities node should be a scalar or a list", node) + throw TaintParseError("The taint-entities node should be a scalar or a list", node) } } /** - * Constructs [TaintEntity] by the given [name] &ndash "this", "return" or "argN". + * Constructs [DtoTaintEntity] by the given [name] &ndash "this", "return" or "argN". */ - fun taintEntityByName(name: String): TaintEntity = + fun taintEntityByName(name: String): DtoTaintEntity = when (name) { - Constants.KEY_THIS -> ThisObject - Constants.KEY_RETURN -> ReturnValue + Constants.KEY_THIS -> DtoTaintEntityThis + Constants.KEY_RETURN -> DtoTaintEntityReturn else -> { val index = name.removePrefix(Constants.KEY_ARG).toUIntOrNull() - ?: throw ConfigurationParseError("Method argument should be like `arg` + index, but is `$name`") + ?: throw TaintParseError("Method argument should be like `arg` + index, but is `$name`") validate(index >= 1u, "Method arguments indexes are numbered from one, but index = `$index`") - MethodArgument(index) + DtoTaintEntityArgument(index) } } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintMarkParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintMarkParser.kt index ca904949ae..c326c19fdd 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintMarkParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintMarkParser.kt @@ -3,10 +3,10 @@ package org.utbot.taint.parser.yaml import com.charleskorn.kaml.YamlList import com.charleskorn.kaml.YamlNode import com.charleskorn.kaml.YamlScalar -import org.utbot.taint.parser.model.AllTaintMarks -import org.utbot.taint.parser.model.TaintMarksSet -import org.utbot.taint.parser.model.TaintMark -import org.utbot.taint.parser.model.TaintMarks +import org.utbot.taint.parser.model.DtoTaintMarksAll +import org.utbot.taint.parser.model.DtoTaintMarksSet +import org.utbot.taint.parser.model.DtoTaintMark +import org.utbot.taint.parser.model.DtoTaintMarks import kotlin.contracts.ExperimentalContracts @OptIn(ExperimentalContracts::class) @@ -19,24 +19,24 @@ object TaintMarkParser { * * `[ sensitive-data, xss ]` */ - fun parseTaintMarks(node: YamlNode): TaintMarks = + fun parseTaintMarks(node: YamlNode): DtoTaintMarks = when (node) { is YamlScalar -> { - TaintMarksSet(setOf(TaintMark(node.content))) + DtoTaintMarksSet(setOf(DtoTaintMark(node.content))) } is YamlList -> { if (node.items.isEmpty()) { - AllTaintMarks + DtoTaintMarksAll } else { val marks = node.items.map { innerNode -> validate(innerNode is YamlScalar, "The mark name should be a scalar", innerNode) - TaintMark(innerNode.content) + DtoTaintMark(innerNode.content) } - TaintMarksSet(marks.toSet()) + DtoTaintMarksSet(marks.toSet()) } } else -> { - throw ConfigurationParseError("The marks node should be a scalar or a list", node) + throw TaintParseError("The marks node should be a scalar or a list", node) } } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/RuleParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintRuleParser.kt similarity index 81% rename from utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/RuleParser.kt rename to utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintRuleParser.kt index c6670e5471..15f466a5a7 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/RuleParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintRuleParser.kt @@ -4,42 +4,42 @@ import com.charleskorn.kaml.YamlList import com.charleskorn.kaml.YamlMap import com.charleskorn.kaml.YamlNode import org.utbot.taint.parser.model.* -import org.utbot.taint.parser.yaml.ConditionParser.parseConditionsKey -import org.utbot.taint.parser.yaml.SignatureParser.parseSignatureKey +import org.utbot.taint.parser.yaml.TaintConditionParser.parseConditionsKey +import org.utbot.taint.parser.yaml.TaintSignatureParser.parseSignatureKey import org.utbot.taint.parser.yaml.TaintEntityParser.parseTaintEntities import org.utbot.taint.parser.yaml.TaintMarkParser.parseTaintMarks import kotlin.contracts.ExperimentalContracts @OptIn(ExperimentalContracts::class) -object RuleParser { +object TaintRuleParser { /** * Recursively parses source rules. * @see parseRules */ - fun parseSources(node: YamlNode): List = - parseRules(node, RuleParser::isSourceRule, RuleParser::parseSourceRule) + fun parseSources(node: YamlNode): List = + parseRules(node, TaintRuleParser::isSourceRule, TaintRuleParser::parseSourceRule) /** * Recursively parses pass-through rules. * @see parseRules */ - fun parsePasses(node: YamlNode): List = - parseRules(node, RuleParser::isPassRule, RuleParser::parsePassRule) + fun parsePasses(node: YamlNode): List = + parseRules(node, TaintRuleParser::isPassRule, TaintRuleParser::parsePassRule) /** * Recursively parses cleaner rules. * @see parseRules */ - fun parseCleaners(node: YamlNode): List = - parseRules(node, RuleParser::isCleanerRule, RuleParser::parseCleanerRule) + fun parseCleaners(node: YamlNode): List = + parseRules(node, TaintRuleParser::isCleanerRule, TaintRuleParser::parseCleanerRule) /** * Recursively parses sink rules. * @see parseRules */ - fun parseSinks(node: YamlNode): List = - parseRules(node, RuleParser::isSinkRule, RuleParser::parseSinkRule) + fun parseSinks(node: YamlNode): List = + parseRules(node, TaintRuleParser::isSinkRule, TaintRuleParser::parseSinkRule) /** * Recursively parses rules (sources/passes/cleaners/sinks). @@ -76,25 +76,25 @@ object RuleParser { /** - * Checks that the [node] can be parsed to [Source]. + * Checks that the [node] can be parsed to [DtoTaintSource]. */ fun isSourceRule(node: YamlNode): Boolean = node.containsKey(Constants.KEY_ADD_TO) && node.containsKey(Constants.KEY_MARKS) /** - * Checks that the [node] can be parsed to [Pass]. + * Checks that the [node] can be parsed to [DtoTaintPass]. */ fun isPassRule(node: YamlNode): Boolean = node.containsKey(Constants.KEY_GET_FROM) && node.containsKey(Constants.KEY_ADD_TO) && node.containsKey(Constants.KEY_MARKS) /** - * Checks that the [node] can be parsed to [Cleaner]. + * Checks that the [node] can be parsed to [DtoTaintCleaner]. */ fun isCleanerRule(node: YamlNode): Boolean = node.containsKey(Constants.KEY_REMOVE_FROM) && node.containsKey(Constants.KEY_MARKS) /** - * Checks that the [node] can be parsed to [Sink]. + * Checks that the [node] can be parsed to [DtoTaintSink]. */ fun isSinkRule(node: YamlNode): Boolean = node.containsKey(Constants.KEY_CHECK) && node.containsKey(Constants.KEY_MARKS) @@ -118,7 +118,7 @@ object RuleParser { * marks: ... * ``` */ - fun parseSourceRule(node: YamlNode, methodNameParts: List): Source { + fun parseSourceRule(node: YamlNode, methodNameParts: List): DtoTaintSource { validate(node is YamlMap, "The source-rule node should be a map", node) validateYamlMapKeys(node, setOf(Constants.KEY_SIGNATURE, Constants.KEY_CONDITIONS, Constants.KEY_ADD_TO, Constants.KEY_MARKS)) @@ -128,7 +128,7 @@ object RuleParser { val addTo = parseTaintEntities(node[Constants.KEY_ADD_TO]!!) val marks = parseTaintMarks(node[Constants.KEY_MARKS]!!) - return Source(methodFqn, addTo, marks, signature, conditions) + return DtoTaintSource(methodFqn, addTo, marks, signature, conditions) } /** @@ -144,7 +144,7 @@ object RuleParser { * marks: ... * ``` */ - fun parsePassRule(node: YamlNode, methodNameParts: List): Pass { + fun parsePassRule(node: YamlNode, methodNameParts: List): DtoTaintPass { validate(node is YamlMap, "The pass-rule node should be a map", node) validateYamlMapKeys(node, setOf(Constants.KEY_SIGNATURE, Constants.KEY_CONDITIONS, Constants.KEY_GET_FROM, Constants.KEY_ADD_TO, Constants.KEY_MARKS)) @@ -155,7 +155,7 @@ object RuleParser { val addTo = parseTaintEntities(node[Constants.KEY_ADD_TO]!!) val marks = parseTaintMarks(node[Constants.KEY_MARKS]!!) - return Pass(methodFqn, getFrom, addTo, marks, signature, conditions) + return DtoTaintPass(methodFqn, getFrom, addTo, marks, signature, conditions) } /** @@ -170,7 +170,7 @@ object RuleParser { * marks: ... * ``` */ - fun parseCleanerRule(node: YamlNode, methodNameParts: List): Cleaner { + fun parseCleanerRule(node: YamlNode, methodNameParts: List): DtoTaintCleaner { validate(node is YamlMap, "The cleaner-rule node should be a map", node) validateYamlMapKeys(node, setOf(Constants.KEY_SIGNATURE, Constants.KEY_CONDITIONS, Constants.KEY_REMOVE_FROM, Constants.KEY_MARKS)) @@ -180,7 +180,7 @@ object RuleParser { val removeFrom = parseTaintEntities(node[Constants.KEY_REMOVE_FROM]!!) val marks = parseTaintMarks(node[Constants.KEY_MARKS]!!) - return Cleaner(methodFqn, removeFrom, marks, signature, conditions) + return DtoTaintCleaner(methodFqn, removeFrom, marks, signature, conditions) } /** @@ -195,7 +195,7 @@ object RuleParser { * marks: ... * ``` */ - fun parseSinkRule(node: YamlNode, methodNameParts: List): Sink { + fun parseSinkRule(node: YamlNode, methodNameParts: List): DtoTaintSink { validate(node is YamlMap, "The sink-rule node should be a map", node) validateYamlMapKeys(node, setOf(Constants.KEY_SIGNATURE, Constants.KEY_CONDITIONS, Constants.KEY_CHECK, Constants.KEY_MARKS)) @@ -205,21 +205,21 @@ object RuleParser { val check = parseTaintEntities(node[Constants.KEY_CHECK]!!) val marks = parseTaintMarks(node[Constants.KEY_MARKS]!!) - return Sink(methodFqn, check, marks, signature, conditions) + return DtoTaintSink(methodFqn, check, marks, signature, conditions) } /** - * Constructs [MethodFqn] from the given [methodNameParts]. + * Constructs [DtoMethodFqn] from the given [methodNameParts]. * * __Input example:__ * * `["org.example", "server", "Controller", "start"]` */ - private fun getMethodFqnFromParts(methodNameParts: List): MethodFqn { + private fun getMethodFqnFromParts(methodNameParts: List): DtoMethodFqn { val parts = methodNameParts.flatMap { it.split('.') } validate(parts.size >= 2, "Method fqn should contain at least the class name and the method name") val packageNames = parts.dropLast(2) val (className, methodName) = parts.takeLast(2) - return MethodFqn(packageNames, className, methodName) + return DtoMethodFqn(packageNames, className, methodName) } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/SignatureParser.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParser.kt similarity index 65% rename from utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/SignatureParser.kt rename to utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParser.kt index 486c6db29b..c635d0d6ac 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/SignatureParser.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/TaintSignatureParser.kt @@ -3,15 +3,15 @@ package org.utbot.taint.parser.yaml import com.charleskorn.kaml.YamlList import com.charleskorn.kaml.YamlMap import com.charleskorn.kaml.YamlNode -import org.utbot.taint.parser.model.AnySignature -import org.utbot.taint.parser.model.Signature -import org.utbot.taint.parser.model.SignatureList +import org.utbot.taint.parser.model.DtoTaintSignatureAny +import org.utbot.taint.parser.model.DtoTaintSignature +import org.utbot.taint.parser.model.DtoTaintSignatureList import org.utbot.taint.parser.yaml.MethodArgumentParser.isArgumentType import org.utbot.taint.parser.yaml.MethodArgumentParser.parseArgumentType import kotlin.contracts.ExperimentalContracts @OptIn(ExperimentalContracts::class) -object SignatureParser { +object TaintSignatureParser { /** * Expects a [YamlMap] with (or without) a key [Constants.KEY_SIGNATURE]. @@ -20,8 +20,8 @@ object SignatureParser { * * `signature: [ _, _, ]` */ - fun parseSignatureKey(ruleMap: YamlMap): Signature = - ruleMap.get(Constants.KEY_SIGNATURE)?.let(SignatureParser::parseSignature) ?: AnySignature + fun parseSignatureKey(ruleMap: YamlMap): DtoTaintSignature = + ruleMap.get(Constants.KEY_SIGNATURE)?.let(TaintSignatureParser::parseSignature) ?: DtoTaintSignatureAny /** * Expects a [YamlList] with argument types as keys. @@ -30,10 +30,10 @@ object SignatureParser { * * `[ _, _, ]` */ - fun parseSignature(node: YamlNode): Signature { + fun parseSignature(node: YamlNode): DtoTaintSignature { validate(node is YamlList, "The signature node should be a list", node) validate(node.items.all(::isArgumentType), "All items should be argument types", node) val argumentTypes = node.items.map(::parseArgumentType) - return SignatureList(argumentTypes) + return DtoTaintSignatureList(argumentTypes) } } \ No newline at end of file diff --git a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/Validation.kt b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/Validation.kt index 2de9391929..913f13f6f3 100644 --- a/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/Validation.kt +++ b/utbot-framework/src/main/kotlin/org/utbot/taint/parser/yaml/Validation.kt @@ -5,7 +5,7 @@ import com.charleskorn.kaml.YamlNode import kotlin.contracts.ExperimentalContracts import kotlin.contracts.contract -class ConfigurationParseError( +class TaintParseError( message: String, node: YamlNode? = null ) : RuntimeException(message + (if (node != null) "\nYaml node: ${node.contentToString()}" else "")) @@ -16,7 +16,7 @@ fun validate(condition: Boolean, reason: String, node: YamlNode? = null) { returns() implies condition } if (!condition) { - throw ConfigurationParseError(reason, node) + throw TaintParseError(reason, node) } } @@ -24,6 +24,6 @@ fun validateYamlMapKeys(node: YamlMap, allowedKeys: Set) { val actualKeys = node.entries.keys.map { it.content }.toSet() val unknownKeys = actualKeys - allowedKeys if (unknownKeys.isNotEmpty()) { - throw ConfigurationParseError("Unknown keys was encountered: $unknownKeys", node) + throw TaintParseError("Unknown keys was encountered: $unknownKeys", node) } }