*
   * @throws NullPointerException if {@code element} is null
   */
  public static <E> ImmutableList<E> of(E element) {
    return construct(element);
  }

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E> ImmutableList<E> of(E e1, E e2) {

    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(NullPointerException.class, () -> cache.get(null));
      checkEmpty(cache);
    }
  }

  public void testGetUnchecked_null() {
    for (LoadingCache<Object, Object> cache : caches()) {
      assertThrows(NullPointerException.class, () -> cache.getUnchecked(null));
      checkEmpty(cache);
    }
  }

  }

  public void testToOptionalNull() {
    Stream<@Nullable Object> stream = Stream.of((Object) null);
    try {
      stream.collect(MoreCollectors.toOptional());
      fail("Expected NullPointerException");
    } catch (NullPointerException expected) {
    }
  }

  public void testToOptionalMultiple() {
    try {
      Stream.of(1, 2).collect(MoreCollectors.toOptional());
      fail("Expected IllegalArgumentException");

      fail("Expected NullPointerException");
    } catch (NullPointerException expected) {
      // success
    }
  }

  @MapFeature.Require(absent = ALLOWS_NULL_VALUE_QUERIES)
  public void testContainsEntryNullDisallowedBecauseValueQueriesDisallowed() {
    try {
      multimap().containsEntry(k3(), null);
      fail("Expected NullPointerException");
    } catch (NullPointerException expected) {

    assertEquals(asList(1, 2, 3), Lists.newArrayList(result));
  }

  public void testAppend_nullPointerException() {
    try {
      FluentIterable<Integer> unused =
          FluentIterable.<Integer>from(asList(1, 2)).append((List<Integer>) null);
      fail("Appending null iterable should throw NPE.");
    } catch (NullPointerException expected) {
    }
  }

  /*
   * Tests for partition(int size) method.
   */

      fail("Should fail on null reference");
    } catch (NullPointerException e) {
    }
  }

  /** Test equalObjects after adding multiple instances at once with a null */
  public void testAddTwoEqualObjectsAtOnceWithNull() {
    try {
      equalsTester.addEqualityGroup(reference, equalObject1, null);
      fail("Should fail on null equal object");
    } catch (NullPointerException e) {
    }
  }

  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_presentNullValueUnsupported() {
    try {
      getMap().replace(k0(), v0(), null);
      fail("Expected NullPointerException");
    } catch (NullPointerException expected) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_VALUE_QUERIES)
  @CollectionSize.Require(absent = ZERO)

   * When multiple elements are equivalent according to {@link Comparable#compareTo}, only the first
   * one specified is included.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E extends Comparable<? super E>> ImmutableSortedSet<E> of(E e1, E e2) {
    return construct(Ordering.natural(), 2, e1, e2);
  }

  /**

    try {
      J.join(ITERABLE_NULL);
      fail();
    } catch (NullPointerException expected) {
    }
    try {
      J.join(ITERABLE_1_NULL_2);
      fail();
    } catch (NullPointerException expected) {
    }

    try {
      J.join(ITERABLE_NULL.iterator());
      fail();
    } catch (NullPointerException expected) {
    }
    try {
      J.join(ITERABLE_1_NULL_2.iterator());
      fail();

import static org.junit.jupiter.api.Assertions.assertThrows;

class UrlSourceTest {

    @Test
    void testUrlSource() {
        NullPointerException e = assertThrows(
                NullPointerException.class, () -> new UrlSource(null), "Should fail, since you must specify a url");
        assertEquals("url cannot be null", e.getMessage());
    }

    @Test