assertThrows(
        NullPointerException.class,
        () -> Maps.toMap((Iterable<String>) strings, Functions.constant("foo")));
  }

  public void testToMapWithNullValues() {
    Iterable<String> strings = ImmutableList.of("one", "two", "three");
    assertThrows(NullPointerException.class, () -> Maps.toMap(strings, Functions.constant(null)));
  }

  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_QUERIES)
  public void testContainsAll_nullNotAllowed() {
    try {
      assertFalse(collection.containsAll(MinimalCollection.of((E) null)));
    } catch (NullPointerException tolerated) {
    }
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContainsAll_nullAllowed() {
    assertFalse(collection.containsAll(MinimalCollection.of((E) null)));
  }

    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testAdd_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> collection.add(null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(null)");
  }

    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testAdd_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> collection.add(null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(null)");
  }

   * null} treated as {@link #absent}, use {@link #fromNullable} instead.
   *
   * <p><b>Comparison to {@code java.util.Optional}:</b> no differences.
   *
   * @throws NullPointerException if {@code reference} is null
   */
  public static <T> Optional<T> of(T reference) {
    return new Present<>(checkNotNull(reference));
  }

  /**

   * streams.
   *
   * <p>If the stream has nondeterministic order, this has equivalent semantics to {@link
   * Stream#findAny} (which you might as well use).
   *
   * @see Stream#findFirst()
   * @throws NullPointerException if the last element of the stream is null
   */
  /*
   * By declaring <T> instead of <T extends @Nullable Object>, we declare this method as requiring a

   *
   * @param collection a collection of {@code Number} instances
   * @return an array containing the same values as {@code collection}, in the same order, converted
   *     to primitives
   * @throws NullPointerException if {@code collection} or any of its elements is null
   * @since 1.0 (parameter was {@code Collection<Integer>} before 12.0)
   */
  public static int[] toArray(Collection<? extends Number> collection) {

    try {
      assertEquals(
          "getOrDefault(null, def) should return default or throw",
          v3(),
          getMap().getOrDefault(null, v3()));
    } catch (NullPointerException tolerated) {
    }
  }

  @MapFeature.Require(ALLOWS_NULL_KEYS)
  @CollectionSize.Require(absent = ZERO)
  public void testGetOrDefault_nonNullWhenNullContained() {
    initMapWithNullKey();

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getNetbiosScope()).thenReturn(null);
        // Configure OEM encoding to avoid NullPointerException
        when(mockConfig.getOemEncoding()).thenReturn("UTF-8");
    }

    @Test
    @DisplayName("Constructor with Configuration only should create empty Name instances")
    void testConstructorWithConfigOnly() {

            assertTrue(UniAddress.isDotQuadIP("999.999.999.999"));
        }

        @Test
        void shouldThrowExceptionForNullInput() {
            assertThrows(NullPointerException.class, () -> UniAddress.isDotQuadIP(null));
        }

        @Test
        void shouldThrowExceptionForEmptyInput() {
            assertThrows(StringIndexOutOfBoundsException.class, () -> UniAddress.isDotQuadIP(""));