Fix summarization display name

Author: Markoutte

utbot-fuzzers/src/main/kotlin/org/utbot/fuzzing/JavaLanguage.kt

@@ -62,6 +62,8 @@ suspend fun runJavaFuzzing(
  ).apply {
  compilableName = if (!methodUnderTest.isConstructor) methodUnderTest.name else null
  className = classUnderTest.simpleName
+ canonicalName = classUnderTest.canonicalName
+ isNested = classUnderTest.isNested
  packageName = classUnderTest.packageName
  parameterNameMap = { index ->
  when {

utbot-fuzzers/src/main/kotlin/org/utbot/fuzzing/providers/Primitives.kt

@@ -4,12 +4,11 @@ import org.utbot.framework.plugin.api.ClassId
 import org.utbot.framework.plugin.api.UtPrimitiveModel
 import org.utbot.framework.plugin.api.util.*
 import org.utbot.fuzzer.FuzzedContext
+import org.utbot.fuzzer.FuzzedContext.Comparison.*
 import org.utbot.fuzzer.FuzzedType
 import org.utbot.fuzzer.FuzzedValue
 import org.utbot.fuzzer.providers.ConstantsModelProvider.fuzzed
-import org.utbot.fuzzing.FuzzedDescription
-import org.utbot.fuzzing.Seed
-import org.utbot.fuzzing.ValueProvider
+import org.utbot.fuzzing.*
 import org.utbot.fuzzing.seeds.*
 import java.util.regex.Pattern
 import java.util.regex.PatternSyntaxException
@@ -24,27 +23,70 @@ abstract class PrimitiveValueProvider(
 
  protected suspend fun <T : KnownValue> SequenceScope<Seed<FuzzedType, FuzzedValue>>.yieldKnown(
  value: T,
- description: String = value.toString(),
  toValue: T.() -> Any
  ) {
  yield(Seed.Known(value) { known ->
  UtPrimitiveModel(toValue(known)).fuzzed {
  summary = buildString {
- append("%var% = ")
+ append("%var% = ${known.valueToString()}")
  if (known.mutatedFrom != null) {
- append("mutated from ")
+ append(" (mutated from ${known.mutatedFrom?.valueToString()})")
  }
- append(description)
  }
  }
  })
  }
+
+ private fun <T : KnownValue> T.valueToString(): String {
+ when (this) {
+ is BitVectorValue -> {
+ for (defaultBound in Signed.values()) {
+ if (defaultBound.test(this)) {
+ return defaultBound.name.lowercase()
+ }
+ }
+ return when (size) {
+ 8 -> toByte().toString()
+ 16 -> toShort().toString()
+ 32 -> toInt().toString()
+ 64 -> toLong().toString()
+ else -> toString(10)
+ }
+ }
+ is IEEE754Value -> {
+ for (defaultBound in DefaultFloatBound.values()) {
+ if (defaultBound.test(this)) {
+ return defaultBound.name.lowercase().replace("_", " ")
+ }
+ }
+ return when {
+ is32Float() -> toFloat().toString()
+ is64Float() -> toDouble().toString()
+ else -> toString()
+ }
+ }
+ is StringValue -> {
+ return "'${value.substringToLength(10, "...")}'"
+ }
+ is RegexValue -> {
+ return "'${value.substringToLength(10, "...")}' from $pattern"
+ }
+ else -> return toString()
+ }
+ }
+
+ private fun String.substringToLength(size: Int, postfix: String): String {
+ return when {
+ length <= size -> this
+ else -> substring(0, size) + postfix
+ }
+ }
 }
 
 object BooleanValueProvider : PrimitiveValueProvider(booleanClassId, booleanWrapperClassId) {
  override fun generate(description: FuzzedDescription, type: FuzzedType) = sequence {
- yieldKnown(Bool.TRUE(), description = "true") { toBoolean() }
- yieldKnown(Bool.FALSE(), description = "false") { toBoolean() }
+ yieldKnown(Bool.TRUE()) { toBoolean() }
+ yieldKnown(Bool.FALSE()) { toBoolean() }
  }
 }
 
@@ -80,6 +122,15 @@ object IntegerValueProvider : PrimitiveValueProvider(
 
  private fun ClassId.cast(value: BitVectorValue): Any = tryCast(value)!!
 
+ private val randomStubWithNoUsage = Random(0)
+ private val configurationStubWithNoUsage = Configuration()
+
+ private fun BitVectorValue.change(func: BitVectorValue.() -> Unit): BitVectorValue {
+ return Mutation<KnownValue> { _, _, _ ->
+ BitVectorValue(this).apply { func() }
+ }.mutate(this, randomStubWithNoUsage, configurationStubWithNoUsage) as BitVectorValue
+ }
+
  override fun generate(
  description: FuzzedDescription,
  type: FuzzedType
@@ -90,14 +141,14 @@ object IntegerValueProvider : PrimitiveValueProvider(
  val values = listOfNotNull(
  value,
  when (c) {
- FuzzedContext.Comparison.EQ, FuzzedContext.Comparison.NE, FuzzedContext.Comparison.LE, FuzzedContext.Comparison.GT -> BitVectorValue(value).apply { inc() }
- FuzzedContext.Comparison.LT, FuzzedContext.Comparison.GE -> BitVectorValue(value).apply { dec() }
+ EQ, NE, LE, GT -> value.change { inc() }
+ LT, GE -> value.change { dec() }
  else -> null
  }
  )
  values.forEach {
  if (type.classId.tryCast(it) != null) {
- yieldKnown(it, description = "$it") {
+ yieldKnown(it) {
  type.classId.cast(this)
  }
  }
@@ -109,7 +160,7 @@ object IntegerValueProvider : PrimitiveValueProvider(
  val s = type.classId.typeSize
  val value = bound(s)
  if (type.classId.tryCast(value) != null) {
- yieldKnown(value, description = bound.name.lowercase().replace("_", " ")) {
+ yieldKnown(value) {
  type.classId.cast(this)
  }
  }
@@ -143,12 +194,12 @@ object FloatValueProvider : PrimitiveValueProvider(
  ) = sequence {
  description.constants.forEach { (t, v, _) ->
  if (t in acceptableTypes) {
- yieldKnown(IEEE754Value.fromValue(v), description = "$v") { type.classId.cast(this) }
+ yieldKnown(IEEE754Value.fromValue(v)) { type.classId.cast(this) }
  }
  }
  DefaultFloatBound.values().forEach { bound ->
  val (m, e) = type.classId.typeSize
- yieldKnown(bound(m ,e), description = bound.name.lowercase().replace("_", " ")) {
+ yieldKnown(bound(m ,e)) {
  type.classId.cast(this)
  }
  }
@@ -165,7 +216,7 @@ object StringValueProvider : PrimitiveValueProvider(stringClassId) {
  val values = constants
  .mapNotNull { it.value as? String } +
  sequenceOf("", "abc", "\n\t\r")
- values.forEach { yieldKnown(StringValue(it), description = "predefined string") { value } }
+ values.forEach { yieldKnown(StringValue(it)) { value } }
  constants
  .filter { it.fuzzedContext.isPatterMatchingContext() }
  .map { it.value as String }
@@ -178,7 +229,7 @@ object StringValueProvider : PrimitiveValueProvider(stringClassId) {
  false
  }
  }.forEach {
- yieldKnown(RegexValue(it, Random(0)), description = "regex($it)") { value }
+ yieldKnown(RegexValue(it, Random(0))) { value }
  }
  }
 

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/seeds/BitVectorValue.kt

@@ -232,6 +232,8 @@ enum class Signed : Bound {
  ;
 
  operator fun invoke(size: Int) = BitVectorValue(size, this)
+
+ fun test(value: BitVectorValue) = (0..value.size).all { value[it] == initializer(it, value.size) }
 }
 
 enum class Unsigned : Bound {

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/seeds/IEEE754Value.kt

@@ -112,6 +112,14 @@ class IEEE754Value : KnownValue {
  return result * if (isPositive) 1.0 else -1.0
  }
 
+ fun is32Float(): Boolean {
+ return vector.size == 32 && mantissaSize == 23 && exponentSize == 8
+ }
+
+ fun is64Float(): Boolean {
+ return vector.size == 64 && mantissaSize == 52 && exponentSize == 11
+ }
+
  override fun toString() = buildString {
  for (i in 0 until vector.size) {
  if (i == 1 || i == 1 + exponentSize) append(" ")

utbot-fuzzing/src/main/kotlin/org/utbot/fuzzing/utils/Functions.kt

@@ -85,11 +85,12 @@ internal fun <T> List<T>.transformIfNotEmpty(transform: List<T>.() -> List<T>):
  return if (isNotEmpty()) transform() else this
 }
 
-fun main() {
- val endian = Endian.BE
- println(255.toUByte().toBinaryString(endian))
- println(2.toBinaryString(endian))
- println(BitVectorValue.fromInt(2).toBinaryString(endian))
- print(8.75f.toBinaryString(endian))
- print(8.75.toBinaryString(endian))
-}
+// todo move to tests
+//fun main() {
+// val endian = Endian.BE
+// println(255.toUByte().toBinaryString(endian))
+// println(2.toBinaryString(endian))
+// println(BitVectorValue.fromInt(2).toBinaryString(endian))
+// print(8.75f.toBinaryString(endian))
+// print(8.75.toBinaryString(endian))
+//}