? ((Collection<T>) iterable).stream()
        : StreamSupport.stream(iterable.spliterator(), false);
  }

  /**
   * Returns {@link Collection#stream}.
   *
   * @deprecated There is no reason to use this; just invoke {@code collection.stream()} directly.
   */
  @Deprecated
  @InlineMe(replacement = "collection.stream()")
  public static <T extends @Nullable Object> Stream<T> stream(Collection<T> collection) {

		}
		if result.Objects[4].Name != "obj3" {
			t.Errorf("%s: Expected the object name to be `%s`, but instead found `%s`", instanceType, "obj3", result.Objects[4].Name)
		}
	}
	// check ordering of results with prefix and no paging.
	{
		result, err = obj.ListObjects(context.Background(), "bucket", "new", "", "", 5)
		if err != nil {
			t.Fatalf("%s: <ERROR> %s", instanceType, err)
		}
		if result.Objects[0].Name != "newPrefix" {

    assertThrows(NullPointerException.class, () -> ImmutableList.of("a", null, "b"));
  }

  public void testCreation_generic() {
    List<String> a = ImmutableList.of("a");
    // only verify that there is no compile warning
    ImmutableList<List<String>> unused = ImmutableList.of(a, a);
  }

  public void testCreation_arrayOfArray() {
    String[] array = new String[] {"a"};

    }
  }


  public void testScanFromFile_fileNotExists() throws IOException {
    ClassLoader classLoader = ClassPathTest.class.getClassLoader();
    assertThat(
            new ClassPath.LocationInfo(new File("no/such/file/anywhere"), classLoader)
                .scanResources())
        .isEmpty();
  }

  @AndroidIncompatible // ClassPath is documented as not supporting Android

      return new RegularImmutableMap<K, V>(null, alternatingKeysAndValues, 1);
    }
    checkPositionIndex(n, alternatingKeysAndValues.length >> 1);
    int tableSize = ImmutableSet.chooseTableSize(n);
    // If there are no duplicate keys, hashTablePlus is the final hashTable value. If there *are*
    // duplicate keys, hashTablePlus consists of 3 elements: [0] the hashTable; [1] the number of

      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

 * methods will throw {@link NullPointerException} if any given element is null.
 *
 * <p><b>Warning: joiner instances are always immutable</b>; a configuration method such as {@code
 * useForNull} has no effect on the instance it is invoked on! You must store and use the new joiner
 * instance returned by the method. This makes joiners thread-safe, and safe to store as {@code
 * static final} constants.
 *
 * {@snippet :

            assertNull(result.getPath());
            assertEquals(consumed, result.getPathConsumed());
        }

        @Test
        @DisplayName("Should use special name when no expanded names")
        void testFromReferralWithSpecialName() {
            when(mockReferral.getTtl()).thenReturn(300);
            when(mockReferral.getRFlags()).thenReturn(Trans2GetDfsReferralResponse.FLAGS_NAME_LIST_REFERRAL);

                    && !lowerData.contains("key") && !lowerData.contains("credential") && !lowerData.contains("auth")) {
                return data; // No sensitive patterns detected, skip regex
            }
        }

        // Mask passwords and secrets using cached pattern
        return PASSWORD_PATTERN.matcher(data).replaceAll("$1$2****");
    }

### Without `fastapi-cloud-cli` { #without-fastapi-cloud-cli }

If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.

### Additional Optional Dependencies { #additional-optional-dependencies }

There are some additional dependencies you might want to install.

Additional optional Pydantic dependencies: