if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
@REM check for pre script, once with legacy .bat ending and once with .cmd ending
if exist "%HOME%\mavenrc_pre.bat" call "%HOME%\mavenrc_pre.bat"
if exist "%HOME%\mavenrc_pre.cmd" call "%HOME%\mavenrc_pre.cmd"
:skipRcPre

@setlocal

set ERROR_CODE=0

@REM To isolate internal variables from possible post scripts, we use another setlocal
@setlocal

        assertSame(d, r1, "nextElement should return the same instance");
        // After first call isPrimary should be false
        assertFalse(d.getIsPrimary(), "isPrimary should be cleared after first call");
        // Second call keeps the same state
        SmbComTransactionResponse r2 = (SmbComTransactionResponse) d.nextElement();

     * @param callable the callable to execute
     * @return the result
     * @throws Exception if execution fails or circuit is open
     */
    public <T> T call(Callable<T> callable) throws Exception {
        return call(callable, null);
    }

    /**
     * Execute a callable through the circuit breaker with fallback
     *
     * @param <T> return type

    public int[] batchInsert(List<User> list, RequestOptionCall<BulkRequestBuilder> call) {
        return batchInsert(list, call, null);
    }

    public int[] batchInsert(List<User> list, RequestOptionCall<BulkRequestBuilder> call,
            RequestOptionCall<IndexRequestBuilder> entityCall) {
        return doBatchInsert(new BulkList<>(list, call, entityCall), null);
    }

    public int[] batchUpdate(List<User> list) {

      } else {
        null
      }
    }

    override fun secureConnectStart(call: Call) {
      // Register to capture "Produced ClientHello handshake message".
      currentThread = Thread.currentThread()
      logger.addHandler(loggerHandler)
    }

    override fun secureConnectEnd(
      call: Call,
      handshake: Handshake?,
    ) {
      logger.removeHandler(loggerHandler)
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import okio.Timeout

open class FailingCall : Call {
  override fun request(): Request = error("unexpected")

  override fun execute(): Response = error("unexpected")

  override fun enqueue(responseCallback: Callback): Unit = error("unexpected")

  }

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()
      if (call.request.url.toString() == url) {
        i.remove()
        dispatcherTest.dispatcher.finishedAccessor(call)
        return
      }
    }
    throw AssertionError("No such job: $url")
  }

  override fun shutdown() {
    shutdown = true
  }

// The returned string is heap-allocated, and caller should call free() on it.
TF_CAPI_EXPORT extern const char* TF_GraphDebugString(TF_Graph* graph,
                                                      size_t* len);

// Returns the function content in a human-readable format, with length set in
// `len`. The format is subject to change in the future.
// The returned string is heap-allocated, and caller should call free() on it.
//

OkHttp Coroutines
=================

Support for Kotlin clients using coroutines.

```kotlin
val call = client.newCall(request)

call.executeAsync().use { response ->
  withContext(Dispatchers.IO) {
    println(response.body?.string())
  }
}
```

This is implemented using `suspendCancellableCoroutine`
but uses the standard Dispatcher in OkHttp. This means
that by default Kotlin's Dispatchers are not used.

   *       </ul>
   *   <li>another java.util.Map delegate implementation. In most modern JDKs, normal java.util hash
   *       collections intelligently fall back to a binary search tree if hash table collisions are
   *       detected. Rather than going to all the trouble of reimplementing this ourselves, we
   *       simply switch over to use the JDK implementation wholesale if probable hash flooding is