* {@link #previous} and {@link #distance}, according to their specifications. The methods {@link
 * #minValue} and {@link #maxValue} should also be overridden for bounded types.
 *
 * <p>A discrete domain always represents the <i>entire</i> set of values of its type; it cannot
 * represent partial domains such as "prime integers" or "strings of length 5."
 *
 * <p>See the Guava User Guide section on <a href=

         * Returns the type of pointer, which is always DEPENDENCIES for a DependenciesPointer.
         *
         * @return the DEPENDENCIES pointer type
         */
        @Override
        default Type type() {
            return Type.DEPENDENCIES;
        }
    }

    interface ChildrenPointer extends Pointer {
        /**
         * Returns the type of pointer, which is always CHILDREN for a ChildrenPointer.
         *

 * it requires that the complete universe of rows and columns be specified at construction time.
 * Second, it is always backed by an array large enough to hold a value for every possible
 * combination of row and column keys. (This is rarely optimal unless the table is extremely dense.)
 * Finally, every possible combination of row and column keys is always considered to have a value

#
# Find usage in scripts with e.g.:
#   cd ci/official
#   ls *.sh utilities/*.sh | xargs grep -H --color=always TFCI_ARG_HERE
# You may also get an overview, e.g.:
#   cd ci/official
#   grep -o '^TFCI\w*' envs/ci_default | xargs -n 1 -I{} bash -c "echo; echo {}; grep -R -H --exclude-dir=envs --color=always '{}'"
TFCI_ARTIFACT_FINAL_GCS_ENABLE=
TFCI_ARTIFACT_FINAL_GCS_SA_PATH=
TFCI_ARTIFACT_FINAL_GCS_URI=

        when(delegate.next()).thenReturn(entry1, entry2);

        // Adapter that always throws
        FileEntryAdapterIterator iterator = new FileEntryAdapterIterator(parent, delegate, null) {
            @Override
            protected SmbResource adapt(FileEntry e) throws MalformedURLException {
                throw new MalformedURLException("Always fails");
            }
        };

        TransWaitNamedPipe pipe = new TransWaitNamedPipe("\\\\pipe\\testPipe");
        byte[] buffer = new byte[10];

        // The implementation always returns 0
        int consumed = pipe.readSetupWireFormat(buffer, 0, 4);
        assertEquals(0, consumed, "readSetupWireFormat should always return 0");
    }

    @Test
    public void testWriteParametersWireFormat() {
        // Test that writeParametersWireFormat returns 0

 * is computed from the monotonic duration since system start to ensure consistency
 * between time measurements.
 * <p>
 * This implementation is singleton-based and always uses UTC timezone. The clock
 * cannot be adjusted to different timezones to maintain consistent monotonic behavior.
 * Users needing local time representation should convert the result of {@link #instant()}

   * of response body by the caller.
   *
   * This method is always invoked after [callStart].
   */
  open fun callEnd(call: Call) {
  }

  /**
   * Invoked when a call fails permanently.
   *
   * This method is always invoked after [callStart].
   */
  open fun callFailed(
    call: Call,
    ioe: IOException,
  ) {
  }

        // With name set
        SmbShareInfo info = new SmbShareInfo(TEST_NET_NAME, TEST_TYPE, TEST_REMARK);
        assertEquals(TEST_NET_NAME, info.getName());
    }

    @Test
    @DisplayName("Test getFileIndex always returns 0")
    void testGetFileIndex() {
        // Default instance
        assertEquals(0, shareInfo.getFileIndex());

        // Instance with values

      Predicate<? super T> first, Predicate<? super T> second) {
    // TODO(kevinb): understand why we still get a warning despite @SafeVarargs!
    return Arrays.<Predicate<? super T>>asList(first, second);
  }

  private static <T> List<T> defensiveCopy(T... array) {
    return defensiveCopy(Arrays.asList(array));
  }

  static <T> List<T> defensiveCopy(Iterable<T> iterable) {
    ArrayList<T> list = new ArrayList<>();