void testMirrorStopOnFirstMatch() {
        // exact matches win first
        Mirror mirrorA2 = newMirror("a2", "a,b", "http://a2");
        Mirror mirrorA = newMirror("a", "a", "http://a");
        // make sure repeated entries are skipped
        Mirror mirrorA3 = newMirror("a", "a", "http://a3");

        Mirror mirrorB = newMirror("b", "b", "http://b");
        Mirror mirrorC = newMirror("c", "d,e", "http://de");

  }

  public void testServiceStartupTimes_selfStartingServices() {
    // This tests to ensure that:
    // 1. service times are accurate when the service is started by the manager
    // 2. service times are recorded when the service is not started by the manager (but they may
    // not be accurate).
    Service b =
        new NoOpDelayedService(353) {
          @Override
          protected void doStart() {

	// #include <gmp.h>
	import "C"

is a signal to cgo.  The doc comment on the import of "C" provides
additional context for the C file.  Here it is just a single #include
but it could contain arbitrary C definitions to be imported and used.

Cgo recognizes any use of a qualified identifier C.xxx and uses gcc to
find the definition of xxx.  If xxx is a type, cgo replaces C.xxx with
a Go translation.  C arithmetic types translate to precisely-sized Go

            "ID": "TempUploads",
            "Filter": {
                "Prefix": "temp/"
            },
            "Status": "Enabled"
        }
    ]
}
EOF
```

```
Lifecycle configuration imported successfully to `play/testbucket`.
```

- List the current settings

```
$ mc ilm ls play/testbucket

 * more ACEs are evaluated until all desired access bits (combined)
 * are "allowed". If all of the desired access bits are not "allowed"
 * the then same process is repeated for inherited ACEs.
 * <p>
 * For example, if user <code>WNET\alice</code> tries to open a file
 * with desired access bits <code>0x00000003</code> (<code>FILE_READ_DATA |

        assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");
        assertFalse(emptyIterator.hasNext(), "hasNext should always return false on repeated calls");
    }

    @Test
    @DisplayName("next should return null")
    void testNextReturnsNull() {
        // When
        SmbResource result = emptyIterator.next();

        // Then

 * double myMedian = median().compute(myDataset);
 * }
 *
 * where {@link #median()} has been statically imported.
 *
 * <p>To compute the 99th percentile:
 *
 * {@snippet :
 * double myPercentile99 = percentiles().index(99).compute(myDataset);
 * }
 *
 * where {@link #percentiles()} has been statically imported.
 *
 * <p>To compute median and the 90th and 99th percentiles:
 *
 * {@snippet :

  }

  public void testConcatPeformingFiniteCycle() {
    Iterable<Integer> iterable = asList(1, 2, 3);
    int n = 4;
    Iterable<Integer> repeated = Iterables.concat(nCopies(n, iterable));
    assertThat(repeated).containsExactly(1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3).inOrder();
  }

  public void testPartition_badSize() {
    Iterable<Integer> source = singleton(1);

// profilerWrapper is created because pkg/profiler doesn't
// provide any API to calculate the profiler file path in the
// disk since the name of this latter is randomly generated.
type profilerWrapper struct {
	// Profile recorded at start of benchmark.
	records map[string][]byte
	stopFn  func() ([]byte, error)
	ext     string
}

// record will record the profile and store it as the base.

  // TF_Graph may only / must be deleted when
  //   sessions.size() == 0 && delete_requested == true
  //
  // TODO(b/74949947): mutations currently trigger a warning instead of a bad
  // status, this should be reverted when possible.
  tensorflow::gtl::FlatMap<TF_Session*, tensorflow::string> sessions
      TF_GUARDED_BY(mu);
  bool delete_requested TF_GUARDED_BY(mu);  // set true by TF_DeleteGraph