},
	}

	for i, tc := range testCases {
		t.Run(fmt.Sprintf("Test %d", i+1), func(t *testing.T) {
			got := ExpectedExpiryTime(tc.modTime, int(tc.days))
			if !got.Equal(tc.expected) {
				t.Fatalf("Expected %v to be equal to %v", got, tc.expected)
			}
		})
	}
}

func TestEval(t *testing.T) {
	testCases := []struct {
		inputConfig            string
		objectName             string

		}
		// Failed as expected, but does it fail for the expected reason.
		if actualErr != nil && !testCase.shouldPass {
			if testCase.expectedError.Error() != actualErr.Error() {
				t.Errorf("Test %d: %s: Expected to fail with error \"%s\", but instead failed with error \"%s\" instead.", i+1, instanceType, testCase.expectedError.Error(), actualErr.Error())
			}
		}
		// Test passes as expected, but the output values are verified for correctness here.

			if err != nil && testCase.shouldPass {
				t.Errorf("Test %d: %s:  Expected to pass, but failed with: <ERROR> %s", i+1, instanceType, err.Error())
			}
			if err == nil && !testCase.shouldPass {
				t.Errorf("Test %d: %s: Expected to fail with <ERROR> \"%s\", but passed instead", i+1, instanceType, testCase.err.Error())
			}
			// Failed as expected, but does it fail for the expected reason.
			if err != nil && !testCase.shouldPass {

		if err != testCase.expectedErr {
			t.Errorf("TestXLStorage case %d: Expected: \"%s\", got: \"%s\"", i+1, testCase.expectedErr, err)
		}
		if err == nil {
			for _, expected := range testCase.expectedListDir {
				if !strings.Contains(strings.Join(dirList, ","), expected) {
					t.Errorf("TestXLStorage case %d: Expected the directory listing to be \"%v\", but got \"%v\"", i+1, testCase.expectedListDir, dirList)
				}

      sink.flush()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream finished")
    }
    assertFailsWith<IOException> {
      stream.getSource().read(Buffer(), 1)
    }.also { expected ->
      assertThat(expected.message).isEqualTo("stream was reset: CANCEL")
    }

    // Verify the peer received what was expected.
    val synStream = peer.takeFrame()

		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseExpectedExpression: {
		Code:           "ParseExpectedExpression",
		Description:    "Did not find the expected SQL expression.",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrParseExpectedLeftParenAfterCast: {
		Code:           "ParseExpectedLeftParenAfterCast",

		}
	}

	// expected error response when the unsigned HTTP request is not permitted.
	unsupportedSignature := getAPIError(ErrSignatureVersionNotSupported).HTTPStatusCode
	if rec.Code != unsupportedSignature {

    Iterator<String> iterator = asList("one", "two").iterator();
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterator));
    assertThat(expected).hasMessageThat().isEqualTo("expected one element but was: <one, two>");
  }

  public void testGetOnlyElement_noDefault_fiveElements() {

					t.Fatal(err)
				}
				t.Logf("got expected error: %v", err)
				return
			}

			if err = s3Select.Open(newBytesRSC(testCase.input)); err != nil {
				if !testCase.wantErr {
					t.Fatal(err)
				}
				t.Logf("got expected error: %v", err)
				return
			} else if testCase.wantErr {
				t.Error("did not get expected error")
				return
			}

    Iterator<String> iterator = asList("one", "two").iterator();
    IllegalArgumentException expected =
        assertThrows(IllegalArgumentException.class, () -> getOnlyElement(iterator));
    assertThat(expected).hasMessageThat().isEqualTo("expected one element but was: <one, two>");
  }

  public void testGetOnlyElement_noDefault_fiveElements() {