val thread =
      Thread {
        try {
          call.execute()
          throw AssertionError()
        } catch (expected: IOException) {
        }
      }
    thread.start()
    return thread
  }

  private fun newRequest(url: String): Request = Request.Builder().url(url).build()

  private fun newRequest(
    url: String,
    tag: String,
  ): Request =
    Request

        private static FileEntry staticInitial;
        private static List<FileEntry[]> staticPages;
        private static boolean staticThrowOnOpen;

        private int pageIdx = -1; // Start before first page
        private boolean done = false;
        private boolean throwOnFetch;
        private boolean throwOnCloseInternal;

        // Use static factory method to work around constructor ordering

                        success[index] = false;
                    }
                });
            }

            // When
            for (Thread thread : threads) {
                thread.start();
            }
            for (Thread thread : threads) {
                thread.join();
            }

            // Then
            for (int i = 0; i < threadCount; i++) {

                    }
                }
            }
            if (!taskList.isEmpty()) {
                storeQueue(taskList);
            }
        }, "ThumbnailGenerator");
        thumbnailQueueThread.start();
    }

    /**
     * Cleans up resources when the thumbnail manager is destroyed.
     * Stops background processing and waits for threads to complete.
     */
    @PreDestroy

	if objAPI == nil {
		return errServerNotInitialized
	}

	started := tracker.Started
	if started.IsZero() || started.Equal(timeSentinel) {
		healingLogIf(ctx, fmt.Errorf("unexpected tracker healing start time found: %v", started))
		started = time.Time{}
	}

	// Final tracer update before quitting
	defer func() {
		tracker.setObject("")
		tracker.setBucket("")
		healingLogIf(ctx, tracker.update(ctx))

        .Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket().asBufferedSocket(), "peer")
        .pushObserver(Http2ConnectionTest.IGNORE)
        .listener(realConnection)
        .build()
    connection.start(sendConnectionPreface = false)

    // verify the peer received the ACK
    val ackFrame = peer.takeFrame()
    assertThat(ackFrame.type).isEqualTo(Http2.TYPE_SETTINGS)
    assertThat(ackFrame.streamId).isEqualTo(0)

                size = sfd.getInitialSize();
                resumeKey = rkresp.getResumeKey();

                // start with some reasonably safe defaults, the server will till us if it does not like it
                // can we resume this if we loose the file descriptor?

                int maxChunks = 256;

        writeDirect(b, off, len, 0);
    }

    /**
     * Just bypasses TransWaitNamedPipe - used by DCERPC bind.
     *
     * @param b the byte array containing the data to write
     * @param off the start offset in the data
     * @param len the number of bytes to write
     * @param flags write operation flags
     * @throws IOException if an I/O error occurs
     */

    // Check that we wait long enough anyway (presumably as long as MAX_VALUE nanos):
    TimedWaiterThread waiter = new TimedWaiterThread(future, Long.MAX_VALUE, SECONDS);
    waiter.start();
    waiter.awaitWaiting();

    future.set(1);
    waiter.join();
  }

  @J2ktIncompatible // TODO(b/324550390): Enable
  public void testSetNull() throws Exception {
    future.set(null);

            byte[] buffer = new byte[100];
            TestCreateContextResponse response = new TestCreateContextResponse("BOUNDARY".getBytes(StandardCharsets.UTF_8));

            // Test at buffer start
            int result1 = response.decode(buffer, 0, 10);
            assertEquals(10, result1);

            // Test at buffer end
            int result2 = response.decode(buffer, 90, 10);