}
	for i, test := range specs {
		result := extractPathPrefixAndSuffix(test.path, test.prefix, test.suffix)
		if result != test.expected {
			t.Errorf("unexpected result on test[%v]: expected[%s] but had [%s]", i, test.expected, result)
		}
	}

  }

  public void testForUriStringIPv4() {
    Inet4Address expected = (Inet4Address) InetAddresses.forString("192.168.1.1");
    assertEquals(expected, InetAddresses.forUriString("192.168.1.1"));
  }

  public void testForUriStringIPv6() {
    Inet6Address expected = (Inet6Address) InetAddresses.forString("3ffe:0:0:0:0:0:0:1");
    assertEquals(expected, InetAddresses.forUriString("[3ffe:0:0:0:0:0:0:1]"));
  }

        }

        override fun source(): BufferedSource {
          return Buffer().writeUtf8("hello")
        }
      }
    assertFailsWith<IOException> {
      body.bytes()
    }.also { expected ->
      assertThat(expected.message).isEqualTo(
        "Content-Length (10) and stream length (5) disagree",
      )
    }
  }

  @Test
  fun bytesThrowsMoreThanIntMaxValue() {
    val body: ResponseBody =

      }
      assertEqualsUsingStartedWith(perm, expected, elements);
    }
  }

  /** Regression test for b/4124577 */
  public void testRegression_dataCorruption() {
    int size = 8;
    List<Integer> expected = createOrderedList(size);
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create(expected);
    List<Integer> contents = Lists.newArrayList(expected);

	return &s3Error{
		code:       "ParseExpectedDatePart",
		message:    "Did not find the expected date part in the SQL expression.",
		statusCode: 400,
		cause:      err,
	}
}

func errParseExpectedKeyword(err error) *s3Error {
	return &s3Error{
		code:       "ParseExpectedKeyword",
		message:    "Did not find the expected keyword in the SQL expression.",
		statusCode: 400,
		cause:      err,
	}
}

  }

  private static void checkSha1(String expected, byte[] key, String data) {
    checkSha1(expected, key, data.getBytes(UTF_8));
  }

  private static void checkSha1(String expected, byte[] key, byte[] data) {
    checkHmac(expected, Hashing.hmacSha1(key), data);
  }

  private static void checkMd5(String expected, byte[] key, String data) {
    checkMd5(expected, key, data.getBytes(UTF_8));
  }

		},
	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.restoreHdr)
		if err != tc.expectedErr {
			t.Fatalf("Test %d: got %v expected %v", i+1, err, tc.expectedErr)
		}
		if actual != tc.expectedStatus {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc.expectedStatus)
		}
	}
}

// TestRestoreObjStatusRoundTrip restoreObjStatus roundtrip
func TestRestoreObjStatusRoundTrip(t *testing.T) {

  @Override
  protected void expectContents(Collection<Entry<K, V>> expected) {
    super.expectContents(expected);
    List<Entry<V, K>> reversedEntries = new ArrayList<>();
    for (Entry<K, V> entry : expected) {
      reversedEntries.add(reverseEntry(entry));
    }
    assertEqualIgnoringOrder(getMap().inverse().entrySet(), reversedEntries);

    for (Entry<K, V> entry : expected) {
      assertEquals(

    try {
      final CountDownLatch latch = new CountDownLatch(1);
      RuntimeException expected =
          assertThrows(RuntimeException.class, () -> GcFinalization.await(latch));
      assertWrapsInterruptedException(expected);
    } finally {
      interruptenator.shutdown();
      Thread.interrupted();
    }
  }

	credentials auth.Credentials, t *testing.T,
) {
	// test cases with sample input and expected output.
	testCases := []struct {
		method     string
		bucketName string
		accessKey  string
		secretKey  string
		// Sent body
		body []byte
		// Expected response
		expectedRespStatus int
		lifecycleResponse  []byte
		errorResponse      APIErrorResponse
		shouldPass         bool
	}{