entry = entry.getNextInKeyBucket()) {
      Object candidateKey = entry.getKey();

      /*
       * Assume that equals uses the == optimization when appropriate, and that
       * it would check hash codes as an optimization when appropriate. If we
       * did these things, it would just make things worse for the most
       * performance-conscious users.
       */
      if (key.equals(candidateKey)) {

    return Maps.equalsImpl(this, object);
  }

  @Override
  public int hashCode() {
    // not caching hash code since it could change if map values are mutable
    // in a way that modifies their hash codes
    return entrySet().hashCode();
  }

  @Override
  public String toString() {
    return Maps.toStringImpl(this);
  }

	// It must match the data used during encryption
	// or data key generation.
	AssociatedData Context
}

// MACRequest is a structure containing fields
// and options for generating message authentication
// codes (MAC).
type MACRequest struct {
	// Name is the name of the master key used decrypt
	// the ciphertext.
	Name string

	Version int

	Message []byte
}

        assertEquals(NbtAddress.SMBSERVER_NAME, nbtAddress.firstCalledName());
    }

    @Test
    void testFirstCalledName_SpecialHexCode() {
        // Test firstCalledName with special hex codes
        mockName = new Name(mockConfig, "DOMAIN", 0x1B, null); // Domain Master Browser
        NbtAddress nbtAddress = new NbtAddress(mockName, testAddressInt, false, NbtAddress.H_NODE);

        assertEquals("c", raf.readLine());

        when(raf.read()).thenReturn(-1);
        assertNull(raf.readLine());
    }

    @Test
    @DisplayName("readUTF(): decodes bytes after size prefix")
    void readUTF_decodes() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("r", false, false, false));
        // Size prefix 3, then bytes for "abc"

        src[3] = 'E';
        src[4] = 'C'; // B

        // Use 'X' (0x58) instead of space for padding
        for (int i = 5; i < 31; i += 2) {
            src[i] = 'E';
            src[i + 1] = 'I'; // Encodes to 'X'
        }

        src[31] = 'C';
        src[32] = 'A';
        src[33] = 0x00;

        Name name = new Name(mockConfig);
        name.readWireFormat(src, 0);

    }

    @Override
    public int decode(final byte[] buffer, final int bufferIndex) throws SMBProtocolDecodingException {
        return decode(buffer, bufferIndex, false);
    }

    /**
     * Decodes the SMB2 message from the buffer.
     *
     * @param buffer the buffer containing the message
     * @param bufferIndex the starting position in the buffer
     * @param compound whether this is part of a compound chain

    }
    assertWithMessage("Hex string and dec parm").that(Ints.tryParse("FFFF", 10)).isNull();
    assertWithMessage("Mixed hex case").that(Ints.tryParse("ffFF", 16)).isEqualTo(65535);
  }

  /**
   * Encodes an integer as a string with given radix, then uses {@link Ints#tryParse(String, int)}
   * to parse the result. Asserts the result is the same as what we started with.
   */

		FileHeader: fh,
		offset:     uint64(w.cw.count),
	}

	if strings.HasSuffix(fh.Name, "/") {
		// Set the compression method to Store to ensure data length is truly zero,
		// which the writeHeader method always encodes for the size fields.
		// This is necessary as most compression formats have non-zero lengths
		// even when compressing an empty string.
		fh.Method = Store
		fh.Flags &^= 0x8 // we will not write a data descriptor

### Das Problem reproduzieren { #reproduce-the-problem }

In den meisten Fällen und bei den meisten Fragen gibt es etwas in Bezug auf den **originalen Code** der Person.

In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nicht aus, um **das Problem zu reproduzieren**.