a, m = m, a } if bytes.Compare(b, m) > 0 { b, m = m, b } M, err := NewModulus(m) if err != nil { t.Fatal(err) } A, err := NewNat().SetBytes(a, M) if err != nil { t.Fatal(err) } B, err := NewNat().SetBytes(b, M) if err != nil { t.Fatal(err) } A.Mul(B, M) ABytes := A.Bytes(M) mBig := new(big.Int).SetBytes(m) aBig := new(big.Int).SetBytes(a) bBig := new(big.Int).SetBytes(b) nBig := new(big.Int).Mul(aBig, bBig) nBig.Mod(nBig, mBig) nBigBytes := make([]byte, len(ABytes)) nBig.FillBytes(nBigBytes) if !bytes.Equal(ABytes,...

                        + "\"}}\n" + hit.getSourceAsString() + "\n";
                try {
                    zos.write(data.getBytes(Constants.CHARSET_UTF_8));
                } catch (final IOException e) {
                    logger.warn("Failed to access /{}/{}.", index, hit.getId(), e);
                }
                return true;

                Mockito.mockConstruction(SmbFileInputStream.class, (mock, context) -> {
                    // Mock the read method to return simple content
                    byte[] includeContent = "192.168.1.200 INCLUDEHOST\n".getBytes();
                    int[] index = { 0 };
                    when(mock.read()).thenAnswer(inv -> {
                        if (index[0] < includeContent.length) {

        initializeNetworkExplorer(false, "jCIFS");

        // Setup mock file with minimal required behavior
        String content = "File content for testing";
        byte[] contentBytes = content.getBytes();

        when(smbFile.length()).thenReturn((long) contentBytes.length);
        when(smbFile.getInputStream()).thenReturn(new ByteArrayInputStream(contentBytes));

        // Use spy to avoid actual SMB operations

        byte[] data = new byte[100];

        digest.sign(data, 0, data.length, mockRequest, mockResponse);

        // Check if BSRSPYL signature is written
        byte[] expectedSignature = "BSRSPYL ".getBytes();
        byte[] actualSignature = new byte[8];
        System.arraycopy(data, SmbConstants.SIGNATURE_OFFSET, actualSignature, 0, 8);
        assertArrayEquals(expectedSignature, actualSignature);
    }

    @Test

            try (ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
                try (GZIPOutputStream gos = new GZIPOutputStream(baos)) {
                    gos.write(hash.getBytes(Constants.UTF_8));
                }
                return SIMILAR_DOC_HASH_PREFIX + Base64.getUrlEncoder().withoutPadding().encodeToString(baos.toByteArray());
            } catch (final IOException e) {

     */
    public static String base64(final String value) {
        if (value == null) {
            return StringUtil.EMPTY;
        }
        return Base64.getUrlEncoder().encodeToString(value.getBytes(Constants.CHARSET_UTF_8));
    }

    /**
     * Checks if a file exists at the specified path within the servlet context.
     *
     * @param path the file path relative to the servlet context

        dstIndex += 4;
        SMBUtil.writeInt4(this.createOptions, dst, dstIndex);
        dstIndex += 4;

        final int nameOffsetOffset = dstIndex;
        final byte[] nameBytes = this.name.getBytes(StandardCharsets.UTF_16LE);
        SMBUtil.writeInt2(nameBytes.length, dst, dstIndex + 2);
        dstIndex += 4;

        final int createContextOffsetOffset = dstIndex;
        dstIndex += 4; // createContextOffset

                            try (InputStream contentStream = new BufferedInputStream(new SmbFileInputStream(file))) {
                                responseData.setResponseBody(InputStreamUtil.getBytes(contentStream));
                            } catch (final Exception e) {
                                logger.warn("Failed to read SMB file content: path={}, size={}", filePath, file.getContentLength(), e);

a, m = m, a } if bytes.Compare(b, m) > 0 { b, m = m, b } M, err := NewModulus(m) if err != nil { t.Fatal(err) } A, err := NewNat().SetBytes(a, M) if err != nil { t.Fatal(err) } B, err := NewNat().SetBytes(b, M) if err != nil { t.Fatal(err) } A.Mul(B, M) ABytes := A.Bytes(M) mBig := new(big.Int).SetBytes(m) aBig := new(big.Int).SetBytes(a) bBig := new(big.Int).SetBytes(b) nBig := new(big.Int).Mul(aBig, bBig) nBig.Mod(nBig, mBig) nBigBytes := make([]byte, len(ABytes)) nBig.FillBytes(nBigBytes) if !bytes.Equal(ABytes,...