return response;
    }

    protected static String buildWebConfigJobScript(final String webCofigId) {
        return String.format("return container.getComponent(\"crawlJob\")" + ".logLevel(\"info\")" + ".sessionId(\"%s\")"
                + ".webConfigIds([\"%s\"] as String[])" + ".jobExecutor(executor).execute();", webCofigId, webCofigId);
    }

        }
    }

    private fun String.asArrayType(): String {
        arrayClassIdByElementType[this]?.let { return it }
        return "kotlin.Array<out $this>"
    }

    private val arrayClassIdByElementType: Map<String, String> = buildList<Pair<String, String>> {
        StandardClassIds.primitiveArrayTypeByElementType.mapTo(this) { (classId, arrayClassId) ->

private
fun KtFile.ktClassOf(member: CtClass) =
    collectDescendantsOfType<KtClassOrObject> { it.fqName?.asString() == member.name }.singleOrNull()


private
fun KtDeclaration.isDocumentedAsSince(version: String) =
    docComment?.isSince(version) == true


private
fun KDoc.isSince(version: String) =
    text.contains("@since $version")

            }

            is KaConstantAnnotationValue -> {
                printer.append(value.constantValue.constantValueKind.asString)
                    .append("(")
                    .append(value.constantValue.value.toString())
                    .append(")")
            }

            is KaUnsupportedAnnotationValue -> {

            ConstantValueKind.String -> CompileTimeType.STRING

            else -> CompileTimeType.ANY
        }
    }

    // Unary operators
    private fun FirLiteralExpression.evaluate(function: FirSimpleFunction): FirLiteralExpression? {
        if (value == null) return null
        (value as? String)?.let { opr ->
            evalUnaryOp(

	scope.Debugf("validatePortNumberString %v:", val)
	if !util.IsString(val) {
		return util.NewErrs(fmt.Errorf("validatePortNumberString(%s) bad type %T, want string", path, val))
	}
	if val.(string) == "*" || val.(string) == "" {
		return nil
	}
	intV, err := strconv.ParseInt(val.(string), 10, 32)
	if err != nil {
		return util.NewErrs(fmt.Errorf("%s : %s", path, err))
	}
	return validatePortNumber(path, intV)
}

        then:
        looksLike('<things>\n  <thing foo="bar"/>\n</things>', writer.toString())
    }

    private void looksLike(String expected, String actual) {
        assert removeTrailingWhitespace(actual) == removeTrailingWhitespace(TextUtil.toPlatformLineSeparators("<?xml version=\"1.0\"?>\n" + expected))
    }

    private void looksLike(String expected, byte[] actual) {

        return actionExecution.empty ? null : Iterables.getOnlyElement(actionExecution)
    }

    String buildCacheKeyFor(String identity) {
        def execution = transformExecutions.find { it.details.identity == identity }
        def snapshotExecution = snapshotInputsOperation(execution).result
        return snapshotExecution.hash as String
    }

    void enableIdentityCache() {
        // So we don't get a daemon from another test

				Header: map[string][]string{
					"X-Real-Ip": {invalidIPString},
				},
			},
		},
		{
			Request: http.Request{
				Header: map[string][]string{
					"X-Forwarded-For": {ipString},
				},
			},
			ExpectedIP: ip,
		},
		{
			Request: http.Request{
				Header: map[string][]string{
					"X-Forwarded-For": {invalidIPString},
				},
			},
		},
		{
			Request: http.Request{

            is Name -> printer.append(value.asString())
            is FqName -> printer.append(value.asString())
            is ClassId -> printer.append(value.asString())
            is DeprecationInfo -> renderDeprecationInfo(value, printer)
            is Visibility -> printer.append(value::class.java.simpleName)
            // Unsigned integers
            is UByte -> printer.append(value.toString())