* You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */

    void testDecodeNonAlignedNextOffset() {
        byte[] buffer = new byte[100];
        // Write non-aligned next entry offset (not divisible by 4)
        SMBUtil.writeInt4(7, buffer, 0); // 7 is not aligned to 4 bytes
        SMBUtil.writeInt4(FileNotifyInformation.FILE_ACTION_ADDED, buffer, 4);
        SMBUtil.writeInt4(8, buffer, 8); // file name length

            SmbComNtCancel cancel = constructor.newInstance(mockConfig, testMid);

            // Then
            assertNotNull(cancel);
            assertEquals(testMid, cancel.getMid());

            // Verify command is set correctly
            Field commandField = ServerMessageBlock.class.getDeclaredField("command");
            commandField.setAccessible(true);
            assertEquals(SMB_COM_NT_CANCEL, commandField.getByte(cancel));
        }

        void testConstructorWithStringInvalidCharacter() {
            // Arrange
            String invalidUuid = "00112233-4455-6677-8899-AABBCCDDEXX"; // 'X' is invalid

            // Act & Assert
            assertThrows(IllegalArgumentException.class, () -> new UUID(invalidUuid),
                    "Should throw IllegalArgumentException for invalid character in UUID string");

/*
 * © 2025 CodeLibs, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of

                if (logger.isDebugEnabled()) {
                    logger.debug("The content length is 0.");
                }
                return new ExtractData(StringUtil.EMPTY);
            } else {
                try (InputStream is = getContentInputStream(out)) {
                    return extractor.getText(is, params);
                }
            }
        } catch (final CrawlingAccessException e) {

import org.codelibs.fess.mylasta.action.FessMessages;
import org.lastaflute.web.validation.VaMessenger;

/**
 * Exception thrown when an invalid query is encountered.
 * This exception is typically used in search contexts where a provided
 * query is malformed, contains invalid syntax, or violates query constraints.
 */
public class InvalidQueryException extends FessSystemException {

    /** Serial version UID for serialization */

 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.convert;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertEquals;

import java.util.Calendar;

}

// IsARM64ADR reports whether the op (as defined by an arm64.A* constant) is
// one of the comparison instructions that require special handling.
func IsARM64ADR(op obj.As) bool {
	switch op {
	case arm64.AADR, arm64.AADRP:
		return true
	}
	return false
}

// IsARM64CMP reports whether the op (as defined by an arm64.A* constant) is
// one of the comparison instructions that require special handling.