return ITEM_ENDPOINT_SUFFIX + "/" + dictId;
    }

    @BeforeEach
    protected void initializeDictId() {
        final Map<String, Object> searchBody = new HashMap<>();
        final String response = checkMethodBase(searchBody).get("/api/admin/dict").asString();
        final List<Map<String, String>> dicts = JsonPath.from(response).getList("response.settings");

        if (descriptor == null) {
            val name = when (builder) {
                is KaClassTypeBuilder.ByClassId -> builder.classId.asString()
                is KaClassTypeBuilder.BySymbol ->
                    builder.symbol.classId?.asString()
                        ?: builder.symbol.name?.asString()
                        ?: SpecialNames.ANONYMOUS_STRING
            }

// Does not compile.

package main

type Bool bool

type Map map[int]int

func (Map) M() {}

type Slice []byte

var slice Slice

func asBool(Bool)     {}
func asString(String) {}

type String string

func main() {
	var (
		b    Bool = true
		i, j int
		c    = make(chan int)
		m    = make(Map)
	)

	asBool(b)
	asBool(!b)
	asBool(true)
	asBool(*&b)
	asBool(Bool(true))

class VfsRelativePathTest extends Specification {

    def "convert absolute path '#absolutePath' to relative path '#relativePath'"() {
        expect:
        VfsRelativePath.of(absolutePath).asString == relativePath

        where:
        absolutePath           | relativePath
        'C:\\'                 | 'C:'
        'C:\\Users\\user'      | 'C:\\Users\\user'
        '/'                    | ''

    @Rule
    public final OriginFixture originBuildInvocationIdFixture = new OriginFixture(delegatingExecuter, temporaryFolder)

    String getBuildInvocationId() {
        scopeIds.buildInvocationId.asString()
    }

    String originBuildInvocationId(String taskPath) {
        originBuildInvocationIdFixture.originId(taskPath)
    }

    void afterBuild() {
        afterExecute*.execute(executer)
    }

                if (parentInternalName != null) "$parentInternalName$$selfName" else null
            }
            else -> selfName.asString()
        }
    }

    private fun computeSupertypeInternalName(descriptor: ClassDescriptor): String {
        var interfaceSupertypeInternalName: String? = null

        for (supertype in descriptor.typeConstructor.supertypes) {

                        sizeof(tensorflow::tstring), params.status);
  if (TF_GetCode(params.status) != TF_OK) {
    TF_DeleteTensor(summary_tensor);
    TF_OpKernelContext_Failure(ctx, params.status);
    return;
  }
  tensorflow::tstring* output_tstring =
      reinterpret_cast<tensorflow::tstring*>(TF_TensorData(summary_tensor));
  CHECK(SerializeToTString(s, output_tstring));

#import <iostream>
#import "greeter.h"

@implementation Greeter

- (void) sayHello {
    NSString *helloWorld = @"Hello world!";
    std::cout << [helloWorld UTF8String] << std::endl;
}

			types.IsSimple[et] = true
		}
	}

	types.IsSimple[types.TBOOL] = true

	okforadd[types.TSTRING] = true

	okforbool[types.TBOOL] = true

	okforcap[types.TARRAY] = true
	okforcap[types.TCHAN] = true
	okforcap[types.TSLICE] = true

	ir.OKForConst[types.TBOOL] = true
	ir.OKForConst[types.TSTRING] = true

	okforlen[types.TARRAY] = true
	okforlen[types.TCHAN] = true
	okforlen[types.TMAP] = true

private
fun <T> T.matchesNameAndIsSince(candidateName: String, version: String): Boolean where T : BodyDeclaration<*>, T : NodeWithSimpleName<*> =
    takeIf { it.matchesName(candidateName) }?.isSince(version) == true


private
fun <T : NodeWithSimpleName<*>> T.matchesName(candidateName: String) =
    matchesName(name.asString(), candidateName)


private
fun matchesName(name: String, candidateName: String) =