encodeSet = FORM_ENCODE_SET,
            alreadyEncoded = true,
            plusIsSpace = true,
            charset = charset,
          )
      }

      fun build(): FormBody = FormBody(names, values)
    }

  companion object {
    private val CONTENT_TYPE: MediaType = "application/x-www-form-urlencoded".toMediaType()
  }

// Performs various checks.
Status ComputeBodyNodes(
    const TF_Graph* fn_body, const char* fn_name, int num_opers,
    const TF_Operation* const* opers,
    const std::unordered_map<const Node*, std::vector<int>>& input_nodes,
    std::vector<const Node*>* body_nodes)
    TF_EXCLUSIVE_LOCKS_REQUIRED(fn_body->mu) {
  if (num_opers == -1) {
    for (const Node* node : fn_body->graph.op_nodes()) {
      const auto& iter = input_nodes.find(node);

        when:
        def action = descriptor.toContentFilter()
        details.moduleId >> fooMod
        details.componentId >> DefaultModuleComponentIdentifier.newId(fooMod, version)
        action.execute(details)

        then:
        if (excluded) {
            1 * details.notFound()
        } else {
            0 * details.notFound()
        }


        when:

 */
package okhttp3.recipes.kt

import java.io.IOException
import okhttp3.FormBody
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.OkHttpClient
import okhttp3.Request

class PostForm {
  private val client = OkHttpClient()

  fun run() {
    val formBody =
      FormBody.Builder()
        .add("search", "Jurassic Park")
        .build()
    val request =
      Request(

	}
	return string(b)
}

// NoBody is an [io.ReadCloser] with no bytes. Read always returns EOF
// and Close always returns nil. It can be used in an outgoing client
// request to explicitly signal that a request has zero bytes.
// An alternative, however, is to simply set [Request.Body] to nil.
var NoBody = noBody{}

type noBody struct{}

func (noBody) Read([]byte) (int, error)         { return 0, io.EOF }

  fun encodedPair() {
    val body =
      FormBody.Builder()
        .add("sim", "ple")
        .build()
    val expected = "sim=ple"
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun encodeMultiplePairs() {
    val body =
      FormBody.Builder()
        .add("sim", "ple")

        codeStyle = KaRecommendedRendererCodeStyle
        modifiersRenderer = KaDeclarationModifiersRendererForSource.NO_IMPLICIT_MODIFIERS
        classifierBodyRenderer = KaClassifierBodyRenderer.NO_BODY
        bodyMemberScopeProvider = KaRendererBodyMemberScopeProvider.ALL_DECLARED
        bodyMemberScopeSorter = KaRendererBodyMemberScopeSorter.ENUM_ENTRIES_AT_BEGINING

  }

  @Test
  fun formBody() {
    val formBody: FormBody = FormBody.Builder().build()
    val size: Int = formBody.size
    val encodedName: String = formBody.encodedName(0)
    val name: String = formBody.name(0)
    val encodedValue: String = formBody.encodedValue(0)
    val value: String = formBody.value(0)
    val contentType: MediaType = formBody.contentType()

  // Create the kernel.
  Device* dev = flr->device();
  Status s;
  auto props = std::make_shared<NodeProperties>(
      &fbody->record->fdef().signature(), node_def, fbody->arg_types,
      fbody->ret_types);
  OpKernelConstruction construction(DeviceType(dev->device_type()), dev,
                                    dev->GetAllocator(AllocatorAttributes()),

			return
		}

		tc.FuncName = getOpName(runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name())
		tc.RequestRecorder.LogBody = logBody
		tc.ResponseRecorder.LogAllBody = logBody
		tc.ResponseRecorder.LogErrBody = true

		f.ServeHTTP(w, r)
	}
}

func httpTraceAll(f http.HandlerFunc) http.HandlerFunc {
	return httpTrace(f, true)
}

func httpTraceHdrs(f http.HandlerFunc) http.HandlerFunc {