"Constructor" to "AddedClass()",
        "Class" to "AddedEnum",
        "Field" to "FOO"
    ) + reportedMembersFor("AddedEnum", isEnum = true) + listOf(
        "Method" to "AddedEnum.valueOf(java.lang.String)",
        "Method" to "AddedEnum.values()",
        "Class" to "AddedObject",
        "Field" to "INSTANCE",
        "Field" to "cathedral"
    ) + reportedMembersFor("AddedObject") + reportedMembersFor("ExistingClass") + listOf(

	public static final field NONE Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static fun getEntries ()Lkotlin/enums/EnumEntries;
	public static fun valueOf (Ljava/lang/String;)Lokhttp3/logging/HttpLoggingInterceptor$Level;
	public static fun values ()[Lokhttp3/logging/HttpLoggingInterceptor$Level;
}

public abstract interface class okhttp3/logging/HttpLoggingInterceptor$Logger {

	public static final field UPGRADE_TO_SSL_AT_END Lokhttp3/mockwebserver/SocketPolicy;
	public static fun getEntries ()Lkotlin/enums/EnumEntries;
	public static fun valueOf (Ljava/lang/String;)Lokhttp3/mockwebserver/SocketPolicy;
	public static fun values ()[Lokhttp3/mockwebserver/SocketPolicy;

                val coverage = (groupObj["coverage"] as JSONObject).map { entry ->
                    val performanceTestType = PerformanceTestType.valueOf(entry.key as String)
                    performanceTestType to (entry.value as JSONArray).map {
                        Os.valueOf((it as String).uppercase(Locale.US))
                    }.toSet()
                }.toMap()
                PerformanceTestGroup(testProject, coverage)

                added("Constructor", "Bar()"),
                added("Class", "Bazar"),
                added("Method", "Bazar.getEntries()"),
                added("Method", "Bazar.valueOf(java.lang.String)"),
                added("Method", "Bazar.values()"),
                added("Class", "Cathedral"),
                added("Field", "INSTANCE"),
                added("Class", "Foo")
            )
        }

private
fun JApiMethod.isEnumImplicitMethodValueOf(): Boolean {
    return name == "valueOf" && parameters.size == 1 && parameters.first().type == "java.lang.String"
}


private
fun JApiMethod.isEnumImplicitMethodValues(): Boolean {
    return name == "values" && parameters.size == 0

	public static final field IPV6 Lokhttp3/AsyncDns$DnsClass;
	public static fun getEntries ()Lkotlin/enums/EnumEntries;
	public final fun getType ()I
	public static fun valueOf (Ljava/lang/String;)Lokhttp3/AsyncDns$DnsClass;
	public static fun values ()[Lokhttp3/AsyncDns$DnsClass;
}

public abstract interface class okhttp3/Authenticator {
	public static final field Companion Lokhttp3/Authenticator$Companion;

            propertyName to propertyValue
        }
    }.toMap()


/**
 * Creates a [Provider] that returns `true` when this [Provider] has a value
 * and `false` otherwise. The returned [Provider] always has a value.
 * @see Provider.isPresent
 */
private
fun <T> Provider<T>.presence(): Provider<Boolean> =
    map { true }.orElse(false)

    // https://tools.ietf.org/html/rfc7231#section-7.1.3
    // currently ignores a HTTP-date, and assumes any non int 0 is a delay
    if (header.matches("\\d+".toRegex())) {
      return Integer.valueOf(header)
    }
    return Integer.MAX_VALUE
  }

  companion object {
    /**
     * How many redirects and auth challenges should we attempt? Chrome follows 21 redirects; Firefox,

          listOf(
            AttributeTypeAndValue(
              type = ORGANIZATIONAL_UNIT_NAME,
              value = organizationalUnit,
            ),
          )
      }

      result +=
        listOf(
          AttributeTypeAndValue(
            type = ObjectIdentifiers.COMMON_NAME,
            value = commonName ?: UUID.randomUUID().toString(),
          ),
        )

      return result
    }