result = get_openapi_path(
                route=route,
                operation_ids=operation_ids,
                schema_generator=schema_generator,
                model_name_map=model_name_map,
                field_mapping=field_mapping,
                separate_input_output_schemas=separate_input_output_schemas,
            )
            if result:

  val headers: List<Map<String, String>>,
) : Cloneable {
  val headersList: List<Header>
    get() {
      val result = mutableListOf<Header>()
      for (inputHeader in headers) {
        val (key, value) = inputHeader.entries.iterator().next()
        result.add(Header(key, value))
      }
      return result
    }

  public override fun clone() = Case(seqno, this.wire, headers)

        final TimestampConverter converter = new TimestampConverter("yyyy/MM/dd HH:mm:ss");
        final java.sql.Timestamp result = (java.sql.Timestamp) converter.getAsObject("2008/12/31 12:34:56");
        System.out.println(result);
        assertThat(converter.getAsString(result), is("2008/12/31 12:34:56"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testIsTarget() throws Exception {

        request.setSystemProperties(System.getProperties());
        request.setUserSettingsFile(getSettings("simple"));

        SettingsBuildingResult result = builder.build(request);
        assertNotNull(result);
        assertNotNull(result.getEffectiveSettings());
    }

   * generators.
   */
  private List<String> getExtremeValues() {
    List<String> result = new ArrayList<>();
    result.add("!! a");
    result.add("!! b");
    result.add("~~ y");
    result.add("~~ z");
    return result;
  }

  private TestSuite createDescendingSuite(SortedMultisetTestSuiteBuilder<E> parentBuilder) {
    TestMultisetGenerator<E> delegate =

		{ARN{TargetID{"1", "webhook"}, "us-east-1"}, "arn:minio:s3-object-lambda:us-east-1:1:webhook"},
	}

	for i, testCase := range testCases {
		result := testCase.arn.String()

		if result != testCase.expectedResult {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
		}
	}
}

func TestParseARN(t *testing.T) {
	testCases := []struct {
		s           string
		expectedARN *ARN

fun Request.commonNewBuilder(): Request.Builder = Request.Builder(this)

fun Request.commonCacheControl(): CacheControl {
  var result = lazyCacheControl
  if (result == null) {
    result = CacheControl.parse(headers)
    lazyCacheControl = result
  }
  return result
}

internal fun canonicalUrl(url: String): String {
  // Silently replace web socket URLs with HTTP URLs.
  return when {

    List<Method> result = Lists.newArrayList();
    for (Method method : testClass.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && method.getParameterTypes().length == 0
          && method.getName().startsWith("test")) {
        result.add(method);
      }
    }

        })).status(Status.OK).result());
    }

    // PUT /api/admin/fileauth/setting
    @Execute
    public JsonResponse<ApiResult> put$setting(final CreateBody body) {
        validateApi(body, messages -> {});
        if (!isValidFileConfigId(body.fileConfigId)) {
            return asJson(new ApiErrorResponse().message("invalid fileConfigId").status(Status.BAD_REQUEST).result());
        }

      ImmediateExecutionTensorHandle** result) override {
    handle->Ref();
    TF_Status status;
    TFE_TensorHandle* result_handle = device_.copy_tensor_to_device(
        context_, tensorflow::wrap(handle), &status, info_);
    handle->Unref();
    if (!status.status.ok()) return status.status;
    *result = tensorflow::unwrap(result_handle);
    (*result)->Ref();
    TFE_DeleteTensorHandle(result_handle);