this.value1 = value1;
        this.value2 = value2;
        this.value3 = value3;
        this.value4 = value4;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return value1;
    }

    /**
     * Sets the first value.
     *
     * @param value1

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

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

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

     *            The second value
     * @param value3
     *            The third value
     */
    public Tuple3(final T1 value1, final T2 value2, final T3 value3) {
        this.value1 = value1;
        this.value2 = value2;
        this.value3 = value3;
    }

    /**
     * Returns the first value.
     *
     * @return The first value
     */
    public T1 getValue1() {
        return 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);

        docMap.put("key1", "value1");
        docMap.put("key2", "value2");
        docMap.put("key3", "value3");

        Collection<Object> values = docMap.values();
        assertEquals(3, values.size());
        assertTrue(values.contains("value1"));
        assertTrue(values.contains("value2"));
        assertTrue(values.contains("value3"));
    }

    @Test

        value = "  key1  =  value1  \n  key2=value2\n";
        paramMap = ParameterUtil.parse(value);
        assertEquals(2, paramMap.size());
        assertEquals("value1", paramMap.get("key1"));
        assertEquals("value2", paramMap.get("key2"));

        // Test with empty lines and mixed whitespace
        value = "key1=value1\n\n\t\nkey2=value2\n \n";
        paramMap = ParameterUtil.parse(value);

	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)
	}

	want[0] = Level3{
		Level2: Level2{
			Level1s: []Level1{
				{Value: "value1"},
				{Value: "value2"},
			},
		},
		Level2_1: Level2_1{
			Level1s: []Level1{
				{
					Value:   "value1-1",
					Level0s: []Level0{{Value: "Level0-1"}},
				},
				{
					Value:   "value2-2",
					Level0s: []Level0{{Value: "Level0-2"}},
				},
			},
		},
	}