Multiply(context.get(), combined_value.get(), combined_value.get(),
                 status.get()));
    ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());
    std::array<TensorHandlePtr, 2> out_components;
    ExtractPerDeviceValues(context.get(), multiply_result.get(),
                           &out_components, status.get());
    ASSERT_TRUE(TF_GetCode(status.get()) == TF_OK) << TF_Message(status.get());

			ClientKey:       env.Get(clientKeyEnv, kv.Get(target.NATSClientKey)),
			Token:           env.Get(tokenEnv, kv.Get(target.NATSToken)),
			TLS:             env.Get(tlsEnv, kv.Get(target.NATSTLS)) == config.EnableOn,
			TLSSkipVerify:   env.Get(tlsSkipVerifyEnv, kv.Get(target.NATSTLSSkipVerify)) == config.EnableOn,
			PingInterval:    pingInterval,
			QueueDir:        env.Get(queueDirEnv, kv.Get(target.NATSQueueDir)),

	errCode = ErrNone

	if values.Get("max-keys") != "" {
		var err error
		if maxkeys, err = strconv.Atoi(values.Get("max-keys")); err != nil {
			errCode = ErrInvalidMaxKeys
			return
		}
	} else {
		maxkeys = maxObjectList
	}

	prefix = values.Get("prefix")
	marker = values.Get("marker")
	delimiter = values.Get("delimiter")
	encodingType = values.Get("encoding-type")
	return
}

    if (TF_GetCode(status.get()) != TF_OK) return;
    TFE_OpSetDevice(op.get(), device_name, status.get());
    if (TF_GetCode(status.get()) != TF_OK) return;

    TFE_TensorHandle* result_handles;
    int num_retvals = 1;
    TFE_Execute(op.get(), &result_handles, &num_retvals, status.get());
    ASSERT_TRUE(TF_GetCode(status.get()) == TF_INVALID_ARGUMENT)
        << TF_Message(status.get());

	}

	test(getTestTree(), []testCase{
		{"GET", "", "/a", "/a", nil},
		{"Get", "", "/b", "", nil},
		{"Get", "", "/a/b", "/a/b", nil},
		{"Get", "", "/a/c", "/a/{x}", []string{"c"}},
		{"Get", "", "/a/b/", "/a/b/{$}", nil},
		{"Get", "", "/a/b/c", "/a/b/{y}", []string{"c"}},
		{"Get", "", "/a/b/c/d", "/a/b/{x...}", []string{"c/d"}},
		{"Get", "", "/g/h/i", "/g/h/i", nil},
		{"Get", "", "/g/h/j", "/g/{x}/j", []string{"h"}},
	})

        convention.distsDirName == 'distributions'
        convention.distsDirectory.getAsFile().get() == project.layout.buildDirectory.dir('distributions').get().asFile
        convention.libsDirName == 'libs'
        convention.libsDirectory.getAsFile().get() == project.layout.buildDirectory.dir('libs').get().asFile
    }

    def "dirs relative to build dir"() {
        when:

        def homeDirService = servicesBefore.get(SomeHomeDirService)

        expect:
        def services = homeDirServices.getServicesFor(dir)
        services.get(SomeGlobalService).is(globalService)
        services.get(GradleUserHomeDirProvider).is(userHomeDirProvider)
        services.get(SomeHomeDirService).is(homeDirService)
        services.get(SomeHomeDirService).homeDir == dir

                  "subresource": "status",
                  "verbs": [
                    "get",
                    "patch",
                    "update"
                  ]
                }
              ],
              "verbs": [
                "create",
                "delete",
                "deletecollection",
                "get",
                "list",
                "patch",
                "update",

            'Failed to handle GET /a due to unexpected request GET /c. Waiting for 0 further requests, received [GET /a, GET /b], released [], not yet received [GET /c]',
            'Failed to handle GET /b due to unexpected request GET /c. Waiting for 0 further requests, received [GET /a, GET /b], released [], not yet received [GET /c]',

        override val diagnosticClass get() = UnsupportedSuspendTest::class
    }

    interface NewInferenceError : KaFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = NewInferenceError::class
        val error: String
    }

    interface OtherError : KaFirDiagnostic<PsiElement> {
        override val diagnosticClass get() = OtherError::class
    }