public void testDecode() {
        // Create a context and encode it
        Smb2LeaseKey originalKey = new Smb2LeaseKey();
        int originalLeaseState = DirectoryLeaseState.DIRECTORY_FULL;
        DirectoryCacheScope originalScope = DirectoryCacheScope.METADATA_ONLY;

        DirectoryLeaseContext originalContext = new DirectoryLeaseContext(originalKey, originalLeaseState, originalScope);
        originalContext.setMaxCacheAge(60000L);

        // Given
        byte[] originalKey = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        serverData.encryptionKey = originalKey;

        // When - modify the original array
        originalKey[0] = (byte) 0xFF;

        // Then - the field should also be modified (same reference)
        assertEquals((byte) 0xFF, serverData.encryptionKey[0]);
        assertSame(originalKey, serverData.encryptionKey);
    }

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Validate Negotiate Info request data structure. This structure is used to validate
 * that the negotiated SMB2 dialect matches what was originally negotiated.
 *
 * @author mbechler
 *
 */
public class ValidateNegotiateInfoRequest implements Encodable {

    private final int capabilities;
    private final byte[] clientGuid;

import jcifs.internal.SMBProtocolDecodingException;
import jcifs.internal.util.SMBUtil;

/**
 * SMB2 Validate Negotiate Info response data structure. This structure contains the server's
 * validation of the originally negotiated SMB2 dialect.
 *
 * @author mbechler
 *
 */
public class ValidateNegotiateInfoResponse implements Decodable {

    /**
     * Default constructor for ValidateNegotiateInfoResponse
     */

// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

// Originally from https://github.com/gorilla/handlers with following license
// https://raw.githubusercontent.com/gorilla/handlers/master/LICENSE, forked
// and heavily modified for MinIO's internal needs.

package handlers

     * constructed. Model identifiers have the form {@code <groupId>:<artifactId>:<version>}. The first identifier from
     * the list denotes the model on which the model builder was originally invoked. The last identifier will always be
     * an empty string that by definition denotes the super POM.
     *
     * @return The model identifiers from the lineage of models, never {@code null}.
     */

		ErrorHandler:  f.customErrHandler,
	}

	if f.ErrorHandler != nil {
		revproxy.ErrorHandler = f.ErrorHandler
	}

	revproxy.ServeHTTP(w, outReq)
}

// customErrHandler is originally implemented to avoid having the following error
//
//	`http: proxy error: context canceled` printed by Golang
func (f *Forwarder) customErrHandler(w http.ResponseWriter, r *http.Request, err error) {

 */
package okhttp3.internal.http2

import java.io.IOException
import okhttp3.internal.and
import okio.BufferedSink
import okio.BufferedSource
import okio.ByteString

/**
 * This class was originally composed from the following classes in
 * [Twitter Hpack][twitter_hpack].
 *
 *  * `com.twitter.hpack.HuffmanEncoder`
 *  * `com.twitter.hpack.HuffmanDecoder`
 *  * `com.twitter.hpack.HpackUtil`
 *

[community](https://www.tensorflow.org/community) resources that lets
researchers push the state-of-the-art in ML and developers easily build and
deploy ML-powered applications.

TensorFlow was originally developed by researchers and engineers working within
the Machine Intelligence team at Google Brain to conduct research in machine
learning and neural networks. However, the framework is versatile enough to be

	Source          string // Contains line, function and filename requesting the lock.
	Group           bool   // indicates if it was a group lock.
	Owner           string // Owner represents the UUID of the owner who originally requested the lock.
	Quorum          int    // Quorum represents the quorum required for this lock to be active.
	idx             int    `msg:"-"` // index of the lock in the lockMap.
}