executeSynchronously(request).assertFailure("$dns returned no addresses for android.com")
    dns.assertRequests("android.com")
  }

  /** We had a bug where failed HTTP/2 calls could break the entire connection.  */
  @Flaky
  @Test
  fun failingCallsDoNotInterfereWithConnection() {
    enableProtocol(Protocol.HTTP_2)
    server.enqueue(MockResponse(body = "Response 1"))

    assertContent("This connection won't pool properly", response1)
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    // Give the server time to enact the socket policy if it's one that could happen after the
    // client has received the response.
    Thread.sleep(500)
    val response2 = getResponse(newRequest("/b"))
    response1.body.source().timeout().timeout(100, TimeUnit.MILLISECONDS)

                 * exporting the volumes, not the one that we will actually
                 * end up performing IO with. If the server hosting the
                 * actual files has a smaller maxBufSize this could be
                 * incorrect. To handle this properly it is necessary
                 * to redirect the tree to the target server first before
                 * establishing buffer size. These exists() calls facilitate

    public static final String LABELS_pagination_page_guide_msg = "{labels.pagination_page_guide_msg}";

    /** The key of the message: No data. */
    public static final String LABELS_list_could_not_find_crud_table = "{labels.list_could_not_find_crud_table}";

    /** The key of the message: Job Scheduler */
    public static final String LABELS_scheduledjob_configuration = "{labels.scheduledjob_configuration}";

	callbackMutex.Lock()
	callbackToken++
	i := callbackToken
	callbackFuncs[i] = f
	callbackMutex.Unlock()

	// Pass the address of i because the C function was written to
	// take a pointer.  We could pass an int if we felt like
	// rewriting the C code.
	C.callback(unsafe.Pointer(&i))

	callbackMutex.Lock()
	delete(callbackFuncs, i)
	callbackMutex.Unlock()
}

//export goCallback

  return nullptr;
#else
  tensorflow::ServerDef server_def;
  if (!server_def.ParseFromArray(proto, static_cast<int>(proto_len))) {
    status->status = InvalidArgument(
        "Could not parse provided bytes into a ServerDef protocol buffer");
    return nullptr;
  }

  std::unique_ptr<tensorflow::ServerInterface> out_server;
  status->status = tensorflow::NewServer(server_def, &out_server);

case bool, string:
	printString("type is bool or string")  // type of i is type of x (interface{})
default:
	printString("don't know the type")     // type of i is type of x (interface{})
}
</pre>

<p>
could be rewritten:
</p>

<pre>
v := x  // x is evaluated exactly once
if v == nil {
	i := v                                 // type of i is type of x (interface{})
	printString("x is nil")

tes.io/allowedProfileNames: runtime/default # apparmor.security.beta.kubernetes.io/defaultProfileName: runtime/default # # The PSP controller would add corresponding annotations to the pod spec for each container. However, this happens before # the inject adds additional containers, so we must specify them explicitly here. With the above example, we could specify: # injectedAnnotations: # container.apparmor.security.beta.kubernetes.io/istio-init: runtime/default # container.apparmor.security.bet...

operand, as determined by calling the Object.equals(java.lang.Object) method on the examined object. If the specified operand is null then the created matcher will only match if the examined object's equals method returns true when passed a null (which would be a violation of the equals contract), unless the examined object itself is null, in which case the matcher will return a positive match. The created matcher provides a special behaviour when examining Arrays, whereby it will match if both the operand...

this.touchStartX\n      }\n\n      this._handleSwipe()\n      if (this._config.pause === 'hover') {\n        // If it's a touch-enabled device, mouseenter/leave are fired as\n        // part of the mouse compatibility events on first tap - the carousel\n        // would stop cycling until user tapped out of it;\n        // here, we listen for touchend, explicitly pause the carousel\n        // (as if it's the second time we tap on it, mouseenter compat event\n        // is NOT fired) and after a timeout (to allow...