// Verify domain
        String writtenDomain = new String(dst, currentIndex, testDomain.length(), StandardCharsets.US_ASCII);
        assertEquals(testDomain.toUpperCase(), writtenDomain);

        // Verify total bytes written
        assertEquals(currentIndex + testDomain.length() + 1, bytesWritten);
    }

    /**
     * Test the writeParametersWireFormat method for NET_SERVER_ENUM3.
     */
    @Test

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {
    listener.onMessage(this, text)
  }

  @Throws(IOException::class)
  override fun onReadMessage(bytes: ByteString) {
    listener.onMessage(this, bytes)
  }

  @Synchronized override fun onReadPing(payload: ByteString) {
    // Don't respond to pings after we've failed or sent the close frame.

      throws IOException {
    byte[] bytes = decoded.getBytes(UTF_8);
    try (InputStream decodingStream = encoding.decodingStream(new StringReader(encoded))) {
      for (int i = 0; i < bytes.length; i++) {
        assertThat(decodingStream.read()).isEqualTo(bytes[i] & 0xFF);
      }
      assertThat(decodingStream.read()).isEqualTo(-1);
    }
  }

            }
        }

        return key;
    }

    /**
     * Get raw key bytes
     *
     * @param sessionId unique session identifier
     * @return raw key bytes, or null if not found
     */
    public byte[] getRawKey(String sessionId) {
        checkNotClosed();

        byte[] key = rawKeys.get(sessionId);

  static TestSuite suiteForBytes(
      CharSourceFactory factory, byte[] bytes, String name, String desc, boolean slice) {
    TestSuite suite = suiteForString(factory, new String(bytes, UTF_8), name, desc);
    ByteSourceFactory byteSourceFactory = SourceSinkFactories.asByteSourceFactory(factory);
    suite.addTest(
        ByteSourceTester.suiteForBytes(
            byteSourceFactory, bytes, name + ".asByteSource[Charset]", desc, slice));
    return suite;

        }

        this.timeout100Ns = SMBUtil.readInt4(buffer, bufferIndex) & 0xFFFFFFFFL; // Timeout (4 bytes, 100-ns intervals, unsigned)
        this.flags = SMBUtil.readInt4(buffer, bufferIndex + 4); // Flags (4 bytes)
        return 8;
    }

    /**
     * Get the timeout value in 100-nanosecond intervals (raw wire format)
     * @return the timeout in 100-nanosecond intervals

        assertEquals((byte) 'B', SMBUtil.SMB_HEADER[3]);

        // Verify remaining bytes are zeros
        for (int i = 4; i < 24; i++) {
            assertEquals((byte) 0x00, SMBUtil.SMB_HEADER[i]);
        }
    }

    @Test
    void testSMB2Header() {
        assertNotNull(SMBUtil.SMB2_HEADER);
        // The actual header is 68 bytes (4 + 2 + 2 + 2 + 2 + 4 + 2 + 2 + 4 + 4 + 8 + 4 + 4 + 8 + 8 + 8 = 68)

        reader.read("ANY") { header ->
          val bytes = reader.readUnknown()
          return AnyValue(
            tagClass = header.tagClass,
            tag = header.tag,
            constructed = header.constructed,
            length = header.length,
            bytes = bytes,
          )
        }
      }

      override fun toDer(
        writer: DerWriter,

//
// 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/>.

package cmd

import (
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"strconv"
	"testing"
	"time"

	"github.com/minio/minio-go/v7/pkg/signer"

public class KerberosTicket {

    private String serverPrincipalName;
    private String serverRealm;
    private KerberosEncData encData;

    /**
     * Constructs a KerberosTicket from token bytes.
     *
     * @param token the ticket token bytes
     * @param apOptions AP options flags
     * @param keys array of Kerberos keys for decryption
     * @throws PACDecodingException if ticket decoding fails
     */