Thread waiter =
        new Thread() {
          @Override
          public void run() {
            try {
              service.awaitTermination(1, DAYS);
            } catch (InterruptedException e) {
              return;
            }
          }
        };
    waiter.start();
    awaitTimedWaiting(waiter);
    service.shutdown();

		// We should get a no exit code error
		if err == nil || !wantErr.MatchString(err.Error()) {
			t.Errorf("want error matching %s, got %s", wantErr, err)
		}
		// And it should flush all output (even if it looks
		// like we may be getting an exit code)
		if got := out.String(); text != got {
			t.Errorf("want full output %q, got %q", text, got)
		}
	}
	wantErr = regexp.MustCompile("^no exit code")
	check("abc")
	check("exitcode")

    // 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);

			want: []string{"foo", "bar"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := yaml.Unmarshal([]byte(tt.args.yamlStr), &tt.b); (err != nil) != tt.wantErr {
				t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr)
			}
			if !slices.Equal(tt.b.Prefix.F(), tt.want) {
				t.Errorf("UnmarshalYAML() = %v, want %v", tt.b.Prefix.F(), tt.want)
			}
		})
	}

	type (
		testHeader struct { // WriteHeader(hdr) == wantErr
			hdr     Header
			wantErr error
		}
		testWrite struct { // Write(str) == (wantCnt, wantErr)
			str     string
			wantCnt int
			wantErr error
		}
		testReadFrom struct { // ReadFrom(testFile{ops}) == (wantCnt, wantErr)
			ops     fileOps
			wantCnt int64
			wantErr error
		}
		testClose struct { // Close() == wantErr
			wantErr error
		}

Joe Tsai <******@****.***> 1503528984 -0700

		wantMap  sparseDatas
		wantSize int64
		wantErr  error
	}{{
		input:   makeInput(FormatUnknown, ""),
		wantErr: ErrHeader,
	}, {
		input:    makeInput(FormatGNU, "1234", "fewa"),
		wantSize: 01234,
		wantErr:  ErrHeader,
	}, {
		input:    makeInput(FormatGNU, "0031"),
		wantSize: 031,
	}, {
		input:   makeInput(FormatGNU, "80"),
		wantErr: ErrHeader,
	}, {

 *
 */
package mockwebserver3

import java.io.IOException
import okio.BufferedSink

/**
 * The body of a [MockResponse].
 *
 * Unlike [okhttp3.ResponseBody], this interface is designed to be implemented by writers and not
 * called by readers.
 */
public interface MockResponseBody {
  /** The length of this response in bytes, or -1 if unknown. */
  public val contentLength: Long

  @Throws(IOException::class)

	}
	for _, tt := range tests {
		got, err := parseHexUint([]byte(tt.in))
		if tt.wantErr != "" {
			if err != nil && !strings.Contains(err.Error(), tt.wantErr) {
				t.Errorf("parseHexUint(%q) = %v, %v; want error %q", tt.in, got, err, tt.wantErr)
			}
		} else {
			if err != nil || got != tt.want {
				t.Errorf("parseHexUint(%q) = %v, %v; want %v", tt.in, got, err, tt.want)
			}

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

/**
 * Utility methods and classes for I/O; for example input streams, output streams, readers, writers,
 * and files.
 *
 * <p>At the core of this package are the Source/Sink types: {@link ByteSource ByteSource}, {@link
 * CharSource CharSource}, {@link ByteSink ByteSink} and {@link CharSink CharSink}. They are