/** The parameter for occurrence. */
    public static final String AS_OCCURRENCE = "occt";

    /** The parameter for timestamp. */
    public static final String AS_TIMESTAMP = "timestamp";

    /**
     * Returns the query.
     *
     * @return The query.
     */
    public abstract String getQuery();

    /**
     * Returns the fields.
     *

						</la:select>
					</div>
				</div>
			</c:if>
			<div class="mb-3 row">
				<label for="as_timestamp" class="col-lg-3 col-md-4 col-sm-5 col-12 col-form-label"><la:message
						key="labels.advance_search_timestamp"
					/></label>
				<div class="col-lg-5 col-md-8 col-sm-7 col-6">
					<select id="as_timestamp" name="as.timestamp" class="form-control">

						</la:select>
					</div>
				</div>
			</c:if>
			<div class="mb-3 row">
				<label for="as_timestamp" class="col-lg-3 col-md-4 col-sm-5 col-12 col-form-label"><la:message
						key="labels.advance_search_timestamp"
					/></label>
				<div class="col-lg-5 col-md-8 col-sm-7 col-6">
					<select id="as_timestamp" name="as.timestamp" class="form-control">

                        .forEach(q -> queryBuf.append(" site:").append(q.trim())));
        stream(conditions.get(SearchRequestParams.AS_TIMESTAMP))
                .of(stream -> stream.filter(q -> StringUtil.isNotBlank(q) && q.length() <= maxQueryLength)
                        .forEach(q -> queryBuf.append(" timestamp:").append(q.trim())));
    }

    /**

        assertTrue(searchRequestParams.hasConditionQuery());
    }

    public void test_hasConditionQuery_withTimestamp() {
        // Test with timestamp
        testParams.conditions.put(SearchRequestParams.AS_TIMESTAMP, new String[] { "2024-01-01" });
        assertTrue(searchRequestParams.hasConditionQuery());
    }

    public void test_hasConditionQuery_withSiteSearch() {
        // Test with site search

 *
 * @author mbechler
 */
public class AvTimestamp extends AvPair {

    /**
     * Constructs an AvTimestamp from raw byte data
     *
     * @param raw the raw byte data for the timestamp AV pair
     */
    public AvTimestamp(final byte[] raw) {
        super(AvPair.MsvAvTimestamp, raw);
    }

    /**
     * Constructs an AvTimestamp with the specified timestamp value
     *

        byte[] rawBytes = new byte[8];
        SMBUtil.writeInt8(1234567890L, rawBytes, 0); // Example timestamp
        AvTimestamp avTimestamp = new AvTimestamp(rawBytes);

        assertNotNull(avTimestamp);
        assertEquals(AvPair.MsvAvTimestamp, avTimestamp.getType());
        assertArrayEquals(rawBytes, avTimestamp.getRaw());
    }

    /**
     * Test constructor with long timestamp.
     */
    @Test

        assertTrue(pairs.get(0) instanceof AvFlags, "First pair should be AvFlags instance");

        // Check second pair (AvTimestamp)
        assertEquals(AvPair.MsvAvTimestamp, pairs.get(1).getType(), "Second pair should be MsvAvTimestamp");
        assertTrue(pairs.get(1) instanceof AvTimestamp, "Second pair should be AvTimestamp instance");

        // Check third pair (AvTargetName)

import jcifs.ntlmssp.av.AvFlags;
import jcifs.ntlmssp.av.AvPair;
import jcifs.ntlmssp.av.AvPairs;
import jcifs.ntlmssp.av.AvSingleHost;
import jcifs.ntlmssp.av.AvTargetName;
import jcifs.ntlmssp.av.AvTimestamp;

/**
 * Test class for NTLMSSP Type 3 Message functionality
 */
@ExtendWith(MockitoExtension.class)
@DisplayName("Type3Message Tests")
class Type3MessageTest {

    @Mock

    }

    private static AvPair parseAvPair(final int avId, final byte[] raw) {
        return switch (avId) {
        case AvPair.MsvAvFlags -> new AvFlags(raw);
        case AvPair.MsvAvTimestamp -> new AvTimestamp(raw);
        case AvPair.MsvAvTargetName -> new AvTargetName(raw);
        case AvPair.MsvAvSingleHost -> new AvSingleHost(raw);
        case AvPair.MsvAvChannelBindings -> new AvChannelBindings(raw);