<Key>key1</Key>
								<Value>value1</Value>
							</Tag>
							<Tag>
								<Key>key2</Key>
								<Value>value2</Value>
							</Tag>
							</And>
						</Filter>`,
			expectedErr: nil,
		},
		{ // Filter with And and multiple Tag tags
			inputXML: ` <Filter>
							<And>
							<Prefix></Prefix>
							<Tag>
								<Key>key1</Key>
								<Value>value1</Value>
							</Tag>
							<Tag>

        request.setParameterValues("test", new String[] { "value1", "value2", "value1" });
        String[] result = SearchRequestParams.getParamValueArray(request, "test");
        assertEquals(2, result.length);
        assertEquals("value1", result[0]);
        assertEquals("value2", result[1]);
    }

    @Test
    public void test_getParamValueArray_withNullParam() {

						// optimize reflect value length
						valueLen := reflectValue.Len()
						values := make([]interface{}, valueLen)
						for i := 0; i < valueLen; i++ {
							values[i] = reflectValue.Index(i).Interface()
						}

						if len(values) > 0 {
							conds = append(conds, clause.IN{Column: clause.Column{Table: curTable, Name: clause.PrimaryKey}, Values: values})

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() {

        .add("\tkey\t:\tvalue\t") // '\t' also counts as whitespace
        .add("ping:  pong  ") // Value whitespace is trimmed.
        .add("kit:kat") // Space after colon is not required.
        .build()
    assertThat(headers.values("foo")).containsExactly("bar", "baz", "bak")
    assertThat(headers.values("key")).containsExactly("value")
    assertThat(headers.values("ping")).containsExactly("pong")

    }

    @Test
    public void testParamMethod() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

        CurlRequest result = request.param("key1", "value1").param("key2", "value2");

        assertSame(request, result); // Fluent API
    }

    @Test
    public void testParamWithNullValue() {
        CurlRequest request = new CurlRequest(Method.GET, "https://example.com");

[
 {
	 "key_1": "value",
	 "key_2": "value"
 }
]
[
	{
		"key_1": "value2",
		"key_2": "value3"
	}

		{"error not equal", errors.New("1"), errors.New("2"), false},
		{"driver.Valuer equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now, Valid: true}, true},
		{"driver.Valuer not equal", ModifyAt{Time: now, Valid: true}, ModifyAt{Time: now.Add(time.Second), Valid: true}, false},
		{"driver.Valuer equal (ptr to nil ptr)", (*ModifyAt)(nil), &ModifyAt{}, false},
	}
	for _, test := range assertEqualTests {

        crawlingInfoHelper.putToInfoMap("key1", "value1");
        assertNotNull(crawlingInfoHelper.infoMap);

        // Test adding multiple entries
        crawlingInfoHelper.putToInfoMap("key2", "value2");
        crawlingInfoHelper.putToInfoMap("key3", "value3");

        assertEquals("value1", crawlingInfoHelper.infoMap.get("key1"));
        assertEquals("value2", crawlingInfoHelper.infoMap.get("key2"));

    for (i in 0 until size) {
      val name = name(i).lowercase(Locale.US)
      var values: MutableList<String>? = result[name]
      if (values == null) {
        values = ArrayList(2)
        result[name] = values
      }
      values.add(value(i))
    }
    return result
  }

  class Builder {
    internal val namesAndValues: MutableList<String> = ArrayList(20)