byte[] buffer = new byte[] { 0x03, 0x00, // 3 ciphers
                    0x01, 0x00, // AES128_CCM
                    0x02, 0x00, // AES128_GCM
                    0x03, 0x00 // Custom cipher
            };

            // Act
            int decodedSize = context.decode(buffer, 0, buffer.length);

            // Assert
            assertEquals(8, decodedSize);

    * You can have deeply **nested JSON** objects and have them all validated and annotated.
* **Extensible**:
    * Pydantic allows custom data types to be defined or you can extend validation with methods on a model decorated with the validator decorator.

 */
@ExtendWith(MockitoExtension.class)
class NegotiateContextRequestTest {

    @Mock
    private Configuration mockConfig;

    private static final int BUFFER_SIZE = 1024;

    /**
     * Test custom implementation of NegotiateContextRequest for interface testing
     */
    static class TestNegotiateContextRequest implements NegotiateContextRequest {
        private final int contextType;

 *   <li>As prototypes, where a new instance is created each time the component is requested</li>
 * </ul>
 *
 * <p>The container supports component initialization and destruction through consumer functions,
 * allowing custom setup and cleanup operations for components.
 *
 */
public class StandardCrawlerContainer implements CrawlerContainer {

    private static final Logger logger = LogManager.getLogger(StandardCrawlerContainer.class);

 * all elements in priority order and place them in another collection.
 *
 * <p>Operations on this class make no guarantees about the ordering of elements with equal
 * priority. If you need to enforce an ordering, you can define custom classes or comparators that
 * use a secondary key to break ties in primary priority values. For example, here is a class that
 * applies first-in-first-out tie-breaking to comparable elements. To use it, you would insert a

      return true;
    }
  }

  /**
   * Per <a href="https://github.com/google/guava/issues/1635">issue 1635</a>, In JDK 1.7.0_51-b13,
   * {@link TypeVariableImpl#equals(Object)} is changed to no longer be equal to custom TypeVariable
   * implementations. As a result, we need to make sure our TypeVariable implementation respects
   * symmetry. Moreover, we don't want to reconstruct a native type variable {@code <A>} using our

		r, err := hash.NewReader(ctx, bytes.NewReader(b.data), int64(len(b.data)), "", "", int64(len(b.data)))
		bugLogIf(ctx, err)
		custom := b.headerKV()
		_, err = er.putMetacacheObject(ctx, o.objectPath(b.n), NewPutObjReader(r), ObjectOptions{
			UserDefined: custom,
		})
		if err != nil {
			mc.setErr(err.Error())
			cancel()
			return err
		}
		if b.n == 0 {
			return nil
		}

		TraceType: madmin.TraceFTP,
		Time:      startTime,
		NodeName:  globalLocalNodeName,
		FuncName:  s.Method,
		Duration:  time.Since(startTime),
		Path:      s.Filepath,
		Error:     errStr,
		Bytes:     sz,
		Custom: map[string]string{
			"user":   user,
			"cmd":    s.Method,
			"param":  s.Filepath,
			"source": source,
		},
	}
}

func (m *sftpMetrics) log(s *sftp.Request, user string) func(sz int64, err error) {

     * values in the [-128, 127] range are valid for the compact serial form. Non-negative values
     * are reserved for enums defined in BloomFilterStrategies; negative values are reserved for any
     * custom, stateful strategy we may define (e.g. any kind of strategy that would depend on user
     * input).
     */
    int ordinal();
  }

  /** The bit set of the BloomFilter (not necessarily power of 2!) */

                .replace("__DEST_INDEX__", toIndex);
        return reindex(fromIndex, toIndex, source, waitForCompletion);
    }

    /**
     * Performs a reindex operation with custom source configuration.
     *
     * @param fromIndex        the source index name
     * @param toIndex          the destination index name
     * @param source           the reindex configuration JSON