assert response.status_code == 200, response.text
    assert response.json() == [1, 2]


def test_tuple_form_invalid():
    response = client.post("/tuple-form/", data={"values": ("1", "2", "3")})
    assert response.status_code == 422, response.text

    response = client.post("/tuple-form/", data={"values": ("1")})
    assert response.status_code == 422, response.text


def test_openapi_schema():

	}

	err = db.Create(&Museum{Name: "Eye Filmmuseum", CityID: city.ID}).Error
	if err != nil {
		t.Fatalf("failed to create museum: %v", err)
	}

	err = db.Create(&Museum{Name: "Dungeon", CityID: 123}).Error
	if !errors.Is(err, gorm.ErrForeignKeyViolated) {
		t.Fatalf("expected err: %v got err: %v", gorm.ErrForeignKeyViolated, err)
	}

			},
			metadata: map[string]string{
				"content-type": "image/png",
			},
			shouldFail: false,
		},
		// Validate if there are no keys to extract.
		{
			header: http.Header{
				"Test-1": []string{"123"},
			},
			metadata:   map[string]string{},
			shouldFail: false,
		},
		// Validate that there are all headers extracted
		{
			header: http.Header{
				"X-Amz-Meta-Appid":   []string{"amz-meta"},

    webServer.enqueue(
      MockResponse
        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val clientReason = repeat('C', 123)
    val serverReason = repeat('S', 123)
    val webSocket: WebSocket = newWebSocket()
    val server = serverListener.assertOpen()
    clientListener.assertOpen()
    webSocket.close(1000, clientReason)

	}
	if err := s.Err(); err != nil {
		t.Fatal(err)
	}
}

func TestEmptyTokens(t *testing.T) {
	testEmptyTokens(t, "1,2,3,", []string{"1", "2", "3", ""})
}

func TestWithNoEmptyTokens(t *testing.T) {
	testEmptyTokens(t, "1,2,3", []string{"1", "2", "3"})
}

func loopAtEOFSplit(data []byte, atEOF bool) (advance int, token []byte, err error) {
	if len(data) > 0 {
		return 1, data[:1], nil
	}

    table.put("bar", 5, 'c');
    table.put("cat", 8, 'd');
    assertThat(table.rowKeySet()).containsExactly("foo", "cat", "bar").inOrder();
    assertThat(table.row("foo").keySet()).containsExactly(12, 3).inOrder();
  }

  public void testCreateCopy() {
    TreeBasedTable<String, Integer, Character> original =
        TreeBasedTable.create(Collections.reverseOrder(), Ordering.usingToString());

        ImmutableList.of(
            new StreamingVersion().newHasher(),
            new StreamingVersion().newHasher(52),
            new NonStreamingVersion().newHasher(),
            new NonStreamingVersion().newHasher(123));
    Random random = new Random(0);
    for (int i = 0; i < 200; i++) {
      RandomHasherAction.pickAtRandom(random).performAction(random, hashers);
    }
    HashCode[] codes = new HashCode[hashers.size()];

"1.1.1 OK"
"1.1.2 OK"
"1.1.3 OK"
"1.1.4 OK"
"1.1.5 OK"
"1.1.6 OK"
"1.1.7 OK"
"1.1.8 OK"
"1.2.1 OK"
"1.2.2 OK"
"1.2.3 OK"
"1.2.4 OK"
"1.2.5 OK"
"1.2.6 OK"
"1.2.7 OK"
"1.2.8 OK"
"10.1.1 OK"
"12.1.1 UNIMPLEMENTED"
"12.1.10 UNIMPLEMENTED"
"12.1.11 UNIMPLEMENTED"
"12.1.12 UNIMPLEMENTED"
"12.1.13 UNIMPLEMENTED"
"12.1.14 UNIMPLEMENTED"
"12.1.15 UNIMPLEMENTED"
"12.1.16 UNIMPLEMENTED"
"12.1.17 UNIMPLEMENTED"

		js                 = JSON(jsVal)
		esVal              = []byte(`{"Name":"test","Val":"test"}`)
		es                 = ExampleStruct{Name: "test", Val: "test"}
		intVal   intType   = 1
		floatVal floatType = 1.23
	)

	results := []struct {
		SQL           string
		NumericRegexp *regexp.Regexp
		Vars          []interface{}
		Result        string
	}{
		{

func TestIsValidStorageClassKind(t *testing.T) {
	tests := []struct {
		sc   string
		want bool
	}{
		{"STANDARD", true},
		{"REDUCED_REDUNDANCY", true},
		{"", false},
		{"INVALID", false},
		{"123", false},
		{"MINIO_STORAGE_CLASS_RRS", false},
		{"MINIO_STORAGE_CLASS_STANDARD", false},
	}
	for i, tt := range tests {
		if got := IsValid(tt.sc); got != tt.want {