// Test with normal name and values
        String name = "paramName";
        String[] values = { "value1", "value2", "value3" };
        RequestParameter param = new RequestParameter(name, values);

        assertEquals(name, param.getName());
        assertNotNull(param.getValues());
        assertEquals(3, param.getValues().length);
        assertEquals("value1", param.getValues()[0]);

public class StreamUtilTest extends TestCase {

    public void test_ofValues() {
        String[] values = { "value1", "value2" };
        StreamUtil.stream(values[0], values[1]).of(s -> {
            Object[] array = s.toArray();
            for (int i = 0; i < 2; i++) {
                assertEquals(values[i], array[i]);
            }
        });
    }

    public void test_ofNull() {

    public void test_multipleOperations() {
        // Add initial values
        dataStoreParams.put("key1", "value1");
        dataStoreParams.put("key2", 123);

        // Add more values using putAll
        Map<String, String> additionalParams = new HashMap<>();
        additionalParams.put("key3", "value3");
        additionalParams.put("key4", "value4");
        dataStoreParams.putAll(additionalParams);

        facetQueryView.addQuery("label1", "field1:value1");
        facetQueryView.addQuery("label2", "field2:value2");

        facetQueryView.init();

        // Should not modify query map when no filetype queries present
        assertEquals(2, facetQueryView.getQueryMap().size());
        assertEquals("field1:value1", facetQueryView.getQueryMap().get("label1"));
        assertEquals("field2:value2", facetQueryView.getQueryMap().get("label2"));

	switch value := input.(type) {
	case string:
		return json.Unmarshal([]byte(value), l)
	case []byte:
		return json.Unmarshal(value, l)
	default:
		return errors.New("not supported")
	}
}

type Role struct {
	Name string `gorm:"size:256"`
}

func (role *Role) Scan(value interface{}) error {
	if b, ok := value.([]uint8); ok {
		role.Name = string(b)
	} else {
		role.Name = value.(string)
	}

        System.setProperty("custom.prop.one", "value1");
        System.setProperty("custom.prop.two", "value2");
        System.setProperty("other.property", "value3");

        // Test with regex pattern
        execJob.testAddFessCustomSystemProperties(cmdList, "custom\\.prop\\..*");

        assertEquals(2, cmdList.size());
        assertTrue(cmdList.contains("-Dcustom.prop.one=value1"));

                ClosingFuture.from(immediateFuture("value2")),
                ClosingFuture.from(immediateFuture("value3")))
            .call(
                (DeferredCloser closer, TestCloseable v1, String v2, String v3) -> {
                  assertThat(v1).isEqualTo(closeable1);
                  assertThat(v2).isEqualTo("value2");
                  assertThat(v3).isEqualTo("value3");
                  assertStillOpen(closeable1);

        "tags": {"key1": "value1", "key2": "value2"},
    }


def test_validator_is_cloned(client: TestClient):
    with pytest.raises(ResponseValidationError) as err:
        client.get("/model/modelX")
    assert err.value.errors() == [
        {
            "type": "value_error",
            "loc": ("response", "name"),
            "msg": "Value error, name must end in A",
            "input": "modelX",

            .add("field1", 1)
            .addValue("value1")
            .add("field2", "value2");
    String expected = "TestClass{field1=1, value1, field2=value2}";

    assertThat(helper.toString()).isEqualTo(expected);
    // Call toString again
    assertThat(helper.toString()).isEqualTo(expected);

    // Make sure the cached value is reset when we modify the helper at all

	DB.Migrator().AutoMigrate(&Preload{}, &Join{}, &Nested{}, &Value{})

	value1 := Value{
		Name: "value",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p1"}, {Value: "p2"},
			},
			Join: Join{Value: "j1"},
		},
	}
	value2 := Value{
		Name: "value2",
		Nested: Nested{
			Preloads: []*Preload{
				{Value: "p3"}, {Value: "p4"}, {Value: "p5"},
			},