return FluentIterable.from(ImmutableList.<Number>of());
  }

  /*
   * The following tests demonstrate the shortcomings of or() and test that the casting workaround
   * mentioned in the method Javadoc does in fact compile.
   */

  @SuppressWarnings("unused") // compilation test
  public void testSampleCodeError1() {
    Optional<Integer> optionalInt = getSomeOptionalInt();
    // Number value = optionalInt.or(0.5); // error

minio server /tmp/disk{1...4}
```

Now, let's test it out with `mc`:

```sh
mc alias set myminio http://localhost:9000 minio minio123
mc ls myminio
mc mb myminio/test
mc cp /etc/issue myminio/test
mc admin user add myminio foo foobar123
export MC_HOST_foo=http://foo:foobar123@localhost:9000
mc ls foo
mc cp /etc/issue myminio/test/issue2
```

Only the last operation would fail with a permissions error.

        return new SmbFile("smb://test-server/share/");
    }

    // Helper to create a minimal FileEntry mock
    private FileEntry entry(String name, int type) {
        FileEntry e = mock(FileEntry.class);
        when(e.getName()).thenReturn(name);
        when(e.getType()).thenReturn(type);
        return e;
    }

    @Test

if [[ ${BKT_NAME} != "test-bucket" ]]; then
	echo "BUG: Expected bucket: test-bucket, Found: ${BKT_NAME}"
	exit 1
fi

./mc ls myminio1/test-bucket
OBJ_COUNT=$(./mc ls myminio1/test-bucket --json | jq '.key' | wc -l)
if [ "${OBJ_COUNT}" -ne 1 ]; then
	echo "BUG: Expected no of objects: 1, Found: ${OBJ_COUNT}"
	exit 1
fi

OBJ_NAME=$(./mc ls myminio1/test-bucket --json | jq '.key' | sed 's/"//g')

import org.gradle.api.tasks.SourceSet;
import org.gradle.api.tasks.SourceSetContainer;

/**
 * Ideally, this plugin is intended to be temporary and in the long run we want to move
 * forward to port our test fixtures to use the gradle test fixtures plugin.
 * */
public class InternalTestArtifactPlugin implements Plugin<Project> {

    @Override
    public void apply(Project project) {

        Map<String, String> envVarMap = new HashMap<>();
        envVarMap.put("testKey", "testValue");
        envVarMap.put("testSpecialCharactersKey", "<test&Value>");
        OperatingSystemUtils.setEnvVarSource(new TestEnvVarSource(envVarMap));
    }

    @Test
    void testBuildEmptyRequest() throws Exception {
        ToolchainsBuildingRequest request = new DefaultToolchainsBuildingRequest();

  TF_DeleteGraph(graph);
  TF_DeleteStatus(s);
}

TEST(CAPI, Session_Min_CPU) { RunMinTest(/*device=*/"", /*use_XLA=*/false); }

TEST(CAPI, Session_Min_XLA_CPU) { RunMinTest(/*device=*/"", /*use_XLA=*/true); }

TEST(CAPI, Session_Min_GPU) {
  const std::string gpu_device = GPUDeviceName();
  // Skip this test if no GPU is available.
  if (gpu_device.empty()) return;

    fileSystem.read(file) {
      return readStory(this)
    }
  }

  /** Iterate through the hpack-test-case resources, only picking stories for the current draft.  */
  fun storiesForCurrentDraft(): Array<String> {
    val resource =
      HpackJsonUtil::class.java.getResource("/hpack-test-case")
        ?: return arrayOf()

    val testCaseDirectory = File(resource.toURI()).toOkioPath()

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Unit test for {@link FakeTimeLimiter}.
 *
 * @author Jens Nyman
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class FakeTimeLimiterTest extends TestCase {

  private static final int DELAY_MS = 50;

        return props;
    }

    @Test
    void testNullSafe() throws Exception {
        Profile p = Profile.newInstance();

        assertActivation(false, p, newContext(null, null));

        p = p.withActivation(Activation.newInstance());

        assertActivation(false, p, newContext(null, null));
    }

    @Test
    void testPrefix() throws Exception {