**/build/distributions/*.zip => promote-build-distributions
            **/build/releases-data-checkout/data/releases.xml
            **/build/git-checkout/build/reports/integTest/** => distribution-tests
            **/smoke-tests/build/reports/tests/** => post-smoke-tests

	if err := b.parseAllConfigs(ctx, api); err != nil {
		return err
	}

	data := make([]byte, 4, b.Msgsize()+4)

	// Initialize the header.
	binary.LittleEndian.PutUint16(data[0:2], bucketMetadataFormat)
	binary.LittleEndian.PutUint16(data[2:4], bucketMetadataVersion)

	// Marshal the bucket metadata
	data, err := b.MarshalMsg(data)
	if err != nil {
		return err
	}

 */
package mockwebserver3

import okio.Socket

/**
 * Handles a call's request and response streams directly. Use this instead of [MockResponseBody] to
 * begin sending response data before all request data has been received.
 *
 * See [okhttp3.RequestBody.isDuplex].
 */
public interface SocketHandler {
  public fun handle(socket: Socket)

        this.userPrefix = userPrefix;
    }

    /**
     * Extracts role type information from SMB (Server Message Block) response data.
     * Processes both SMB and SMB1 protocols to extract allowed and denied SIDs.
     *
     * @param responseData the response data containing SMB metadata
     * @return a list of role type strings extracted from the SMB permissions
     */

                                            <c:forEach var="data" varStatus="s"
                                                       items="${keyMatchItems}">
                                                <tr
                                                        data-href="${contextPath}/admin/keymatch/details/4/${f:u(data.id)}">
                                                    <td>${f:h(data.term)}</td>

     *
     * @throws CIFSException
     *
     * @see jcifs.smb.SSPContext#calculateMIC(byte[])
     */
    @Override
    public byte[] calculateMIC(byte[] data) throws CIFSException {
        try {
            return this.gssContext.getMIC(data, 0, data.length, new MessageProp(false));
        } catch (GSSException e) {
            throw new CIFSException("Failed to calculate MIC", e);
        }
    }

    /**

import org.codelibs.fess.unit.UnitFessTestCase;

public class DataStoreExceptionTest extends UnitFessTestCase {

    public void test_constructor_withMessage() {
        // Test with message only
        String message = "Data store error occurred";
        DataStoreException exception = new DataStoreException(message);

        assertNotNull(exception);
        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());

                                    <c:if test="${!running and !systemJobId}">
                                        <button type="button" class="btn btn-danger" name="delete"
                                                data-toggle="modal" data-target="#confirmToDelete"
                                                value="<la:message key="labels.crud_button_delete" />">
                                            <em class="fa fa-trash">

	"github.com/klauspost/reedsolomon"
)

// getDataBlockLen - get length of data blocks from encoded blocks.
func getDataBlockLen(enBlocks [][]byte, dataBlocks int) int {
	size := 0
	// Figure out the data block length.
	for _, block := range enBlocks[:dataBlocks] {
		size += len(block)
	}
	return size
}

// Writes all the data blocks from encoded blocks until requested

`UploadFile` tiene los siguientes métodos `async`. Todos ellos llaman a los métodos correspondientes del archivo por debajo (usando el `SpooledTemporaryFile` interno).

* `write(data)`: Escribe `data` (`str` o `bytes`) en el archivo.
* `read(size)`: Lee `size` (`int`) bytes/caracteres del archivo.
* `seek(offset)`: Va a la posición de bytes `offset` (`int`) en el archivo.