assertTrue(fileInfo.toString().contains("endOfFile=" + value));
    }

    @Test
    @DisplayName("Test decode ignores extra buffer length")
    void testDecodeIgnoresExtraLength() throws SMBProtocolDecodingException {
        // Create larger buffer
        byte[] buffer = new byte[100];
        long value = 999L;
        SMBUtil.writeInt8(value, buffer, 0);

	assignments := make([]Assignment, len(values))
	for idx, value := range values {
		assignments[idx] = Assignment{Column: Column{Name: value}, Value: Column{Table: "excluded", Name: value}}
	}
	return assignments

        // Should be 2 bytes for the short value (alignment may add padding)
        assertTrue(bytesUsed >= 2, "Should use at least 2 bytes for short");

        // Reset index to read back
        buf.reset();
        NdrShort decoded = new NdrShort(0); // placeholder value
        decoded.decode(buf);
        assertEquals(expected, decoded.value, "decoded value should match original after masking");
    }

    /**

        for (int i = 0; i < 3; i++) {
            boolQueryBuilder.add(new TermQuery(new Term("must" + i, "value" + i)), BooleanClause.Occur.MUST);
            boolQueryBuilder.add(new TermQuery(new Term("should" + i, "value" + i)), BooleanClause.Occur.SHOULD);
            boolQueryBuilder.add(new TermQuery(new Term("mustNot" + i, "value" + i)), BooleanClause.Occur.MUST_NOT);
        }

        BooleanQuery booleanQuery = boolQueryBuilder.build();

                if (cookieKey.equals(cookie.getName())) {
                    final String value = cookie.getValue();
                    if (logger.isDebugEnabled()) {
                        logger.debug("{}:{}", cookieKey, value);
                    }
                    if (StringUtil.isNotEmpty(value)) {
                        parseRoleSet(value, encryptedCookieValue, roleSet);
                    }
                }
            }

				Columns: []clause.Column{{Name: "age"}},
				Values:  [][]interface{}{{18}},
			},
		},
		{
			name: "Test convert float value",
			input: map[string]interface{}{
				"score": 99.5,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "score"}},
				Values:  [][]interface{}{{99.5}},
			},
		},
		{
			name: "Test convert bool value",
			input: map[string]interface{}{
				"active": true,

        /**
         * Returns the value.
         *
         * @return The value.
         */
        public String getValue() {
            return value;
        }

        /**
         * Sets the value.
         *
         * @param value The value.
         */
        public void setValue(final String value) {
            this.value = value;
        }

        /**

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setValue_LessThan(String value) {
        setValue_LessThan(value, null);
    }

    public void setValue_LessThan(String value, ConditionOptionCall<RangeQueryBuilder> opLambda) {
        final Object _value = value;

    while (sizeRemaining > 0) {
      // The JVM will return interned values for small ints.
      Integer value = random.nextInt(1000) + 128;
      int count = min(random.nextInt(10) + 1, sizeRemaining);
      sizeRemaining -= count;
      hashMultiset.add(value, count);
      linkedHashMultiset.add(value, count);
      treeMultiset.add(value, count);
    }

    protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }