"flags should be DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");
        // Verify that the super constructor was called with the correct handle.
        // This is implicitly tested by the object being created without error and
        // the fields set by the constructor being correct.
    }

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.annotations.Nonnull;
import org.apache.maven.api.model.Model;

/**
 * Provides the super POM that all models implicitly inherit from.
 *
 * @since 4.0.0
 */
@Experimental
public interface SuperPomProvider extends Service {

    /**
     * Gets the super POM for the specified model version.
     *

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.model.superpom;

import org.apache.maven.model.Model;

/**
 * Provides the super POM that all models implicitly inherit from.
 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface SuperPomProvider {

    /**

                "",
                display = ParameterDisplay.PROMPT,
                allowEmpty = true,
                description = "Additional options for the test task to run (`-PrerunAllTests` is already added implicitly)",
            )
        }

        dependencies {
            compileAllDependency(CompileAll.buildTypeId("Check"))
        }

        verify(tree).send((Request<CommonServerMessageBlockResponse>) isNull());
    }

    @Test
    @DisplayName("send with explicit null varargs propagates exception from implementation")
    void send_nullVarargsArray_throws() throws Exception {
        // Arrange: passing explicit null vararg array is edge scenario
        when(tree.send(eq(request), isNull())).thenThrow(new CIFSException("null params"));

        // Verify that the policyHandle passed to the constructor is the one used
        // This is implicitly tested by the object being constructed without errors.
        // If LsaPolicyHandle had methods called by the constructor, we would verify those calls.
    }

 *
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public class MultimapBuilderTest extends TestCase {

  @J2ktIncompatible
  @GwtIncompatible // doesn't build without explicit type parameters on build() methods
  public void testGenerics() {
    ListMultimap<String, Integer> unusedA = MultimapBuilder.hashKeys().arrayListValues().build();
    SortedSetMultimap<String, Integer> unusedB =

  /**
   * Creates a new ArrayBasedCharEscaper instance with the given replacement map and specified safe
   * range. If {@code safeMax < safeMin} then no characters are considered safe. This initializer is
   * useful when explicit instances of ArrayBasedEscaperMap are used to allow the sharing of large
   * replacement mappings.
   *
   * <p>If a character has no mapped replacement then it is checked against the safe range. If it

    Optional<String> z = Optional.of("z");

    Comparator<Optional<String>> comparator = emptiesFirst(comparing(String::length));
    testComparator(comparator, empty, z, abc);

    // Just demonstrate that no explicit type parameter is required
    Comparator<Optional<String>> unused = emptiesFirst(naturalOrder());
  }

  public void testEmptiesLast() {
    Optional<String> empty = Optional.empty();

    assertThat(builder.build().escape("The Quick Brown Fox!")).isEqualTo("XheXXuickXXrownXXoxX");
    // Explicit replacements take priority over unsafe characters.
    builder.addEscape(' ', "_");
    builder.addEscape('!', "_");
    assertThat(builder.build().escape("The Quick Brown Fox!")).isEqualTo("Xhe_Xuick_Xrown_Xox_");
    // Explicit replacements take priority over safe characters.
    builder.setSafeRange(' ', '~');