// When
        MsrpcSamrOpenAlias msrpcSamrOpenAlias = new MsrpcSamrOpenAlias(mockDomainHandle, access, rid, mockAliasHandle);

        // Then
        assertNotNull(msrpcSamrOpenAlias, "MsrpcSamrOpenAlias object should not be null");

        // Verify that ptype and flags are set correctly using reflection
        try {
            java.lang.reflect.Field ptypeField = jcifs.dcerpc.DcerpcMessage.class.getDeclaredField("ptype");

  private final transient ImmutableSortedMultiset<E> forward;

  DescendingImmutableSortedMultiset(ImmutableSortedMultiset<E> forward) {
    this.forward = forward;
  }

  @Override
  public int count(@Nullable Object element) {
    return forward.count(element);
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return forward.lastEntry();
  }

  @Override
  public @Nullable Entry<E> lastEntry() {

import java.util.logging.Logger;
import org.jspecify.annotations.Nullable;

/** A holder for a {@link Logger} that is initialized only when requested. */
@GwtCompatible
final class LazyLogger {
  private final Object lock = new Object();

  private final String loggerName;
  private volatile @Nullable Logger logger;

  LazyLogger(Class<?> ownerOfLogger) {
    this.loggerName = ownerOfLogger.getName();
  }

  Logger get() {

   */

  public static <V extends @Nullable Object> ListenableFuture<V> catching(
      ListenableFuture<? extends V> input,
      Class<Throwable> exceptionType,
      Function<? super Throwable, ? extends V> fallback,
      Executor executor) {
    return AbstractCatchingFuture.create(input, exceptionType, fallback, executor);
  }

  public static <V extends @Nullable Object> ListenableFuture<V> catchingAsync(

  /** Returns a request that transforms `request` to be all uppercase.  */
  private fun uppercaseRequest(request: Request): Request {
    val uppercaseBody: RequestBody =
      object : ForwardingRequestBody(request.body) {
        @Throws(IOException::class)
        override fun writeTo(sink: BufferedSink) {
          delegate().writeTo(uppercaseSink(sink).buffer())
        }
      }

@NullUnmarked
public class StandardMutableUndirectedGraphTest extends AbstractStandardUndirectedGraphTest {

  @Parameters(name = "allowsSelfLoops={0}, incidentEdgeOrder={1}")
  public static Collection<Object[]> parameters() {
    return Arrays.asList(
        new Object[][] {
          {false, ElementOrder.unordered()},
          {true, ElementOrder.unordered()},
          {false, ElementOrder.stable()},
          {true, ElementOrder.stable()},
        });

mapreduce.task.sort.spill.percent=0.9 # Minimum % before spilling to disk
```

        }
        validateFields(body.doc, this::throwValidationErrorApi);
        body.crudMode = CrudMode.CREATE;
        final Map<String, Object> doc = getDoc(body).map(entity -> {
            try {
                entity.putAll(fessConfig.convertToStorableDoc(body.doc));

                final String newId = ComponentUtil.getCrawlingInfoHelper().generateId(entity);

        assertEquals(0, blob.length(), "length() should be 0 for empty");
        assertEquals("", blob.toString(), "toString() of empty should be empty string");
        assertTrue(blob.equals(blob), "Object should be equal to itself");
        assertEquals(blob.get().hashCode(), blob.hashCode(), "hashCode should delegate to internal array");
    }

    // Confirms constructor handles null by producing an empty buffer
    @Test

ry/tempfile.html#tempfile.SpooledTemporaryFile" class="external-link" target="_blank">`SpooledTemporaryFile`</a> (un objeto <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">parecido a un archivo</a>). Este es el objeto de archivo Python real que puedes pasar directamente a otras funciones o paquetes que esperan un objeto "parecido a un archivo".

`UploadFile` tiene los siguientes métodos `async`. Todos ellos llaman a los métodos...