return result;
        }

        @Override
        public void remove() {
          checkForComodification();
          checkState(toRemove != null, "no calls to next() since the last call to remove()");
          ValueSet.this.remove(toRemove.getValue());
          expectedModCount = modCount;
          toRemove = null;
        }
      };
    }

    @Override

        int decoded = newFileInfo.decode(encodeBuffer, 0, size);
        assertEquals(size, decoded);
    }

    /**
     * Test FileInformation implementation with spy to verify method calls
     */
    @Test
    @DisplayName("Test FileInformation implementation with spy")
    void testFileInformationWithSpy() throws SMBProtocolDecodingException {
        // Create spy on real object

)

// metricsCache - cache for metrics.
//
// When serving metrics, this cache is passed to the MetricsLoaderFn.
//
// This cache is used for metrics that would result in network/storage calls.
type metricsCache struct {
	dataUsageInfo       *cachevalue.Cache[DataUsageInfo]
	esetHealthResult    *cachevalue.Cache[HealthResult]
	driveMetrics        *cachevalue.Cache[storageMetrics]

  }

  /**
   * Sets.cartesianProduct doesn't allow sets that contain null, but we want null to mean "don't
   * call the associated CacheBuilder method" - that is, get the default CacheBuilder behavior. This
   * method wraps the elements in the input sets (which may contain null) as Optionals, calls
   * Sets.cartesianProduct with those, then transforms the result to unwrap the Optionals.
   */

     * inputs, rather than as if it never tolerates them.
     *
     * We rely on checkers to implement special cases to catch dangerous calls to join(), etc. based
     * on what they know about the particular Joiner instances the calls are performed on.
     *
     * (In addition to useForNull, we also offer skipNulls. It, too, tolerates null inputs, but its

              }
            } finally {
              lock.unlock();
            }
          });
    }

    @Override
    protected final void doStop() {
      // Both requireNonNull calls are safe because doStop can run only after a successful doStart.
      requireNonNull(runningTask);
      requireNonNull(executorService);
      runningTask.cancel(false);
      executorService.execute(
          () -> {

   *   <li>If {@code equivalent(x, y)} and {@code equivalent(y, z)} are both true, then {@code
   *       equivalent(x, z)} is also true (<i>transitive</i> property)
   * </ul>
   *
   * <p>Note that all calls to {@code equivalent(x, y)} are expected to return the same result as
   * long as neither {@code x} nor {@code y} is modified.
   */
  public final boolean equivalent(@Nullable T a, @Nullable T b) {
    if (a == b) {

        };

        // Execute stop
        dataStore.stop();

        assertTrue(stopCalled.get());
    }

    @Test
    public void test_stop_multipleCalls() {
        // Test multiple stop calls
        final AtomicInteger stopCallCount = new AtomicInteger(0);

        dataStore = new DataStore() {
            @Override

        verify(mockNdrBuffer).align(4);
        verify(mockNdrBuffer, times(2)).dec_ndr_long();
        verify(mockDeferredBuffer, times(3)).dec_ndr_long(); // 1 for array size + 2 for ShareInfo0 decode calls
        verify(mockDeferredBuffer).advance(8); // 4 * 2
    }

    @Test
    void testShareInfoCtr1EncodeWithArray() throws NdrException {
        srvsvc.ShareInfoCtr1 ctr1 = new srvsvc.ShareInfoCtr1();

  /**
   * True if this task faker has ever had multiple tasks scheduled to run concurrently. Guarded by
   * `this`.
   */
  var isParallel = false

  /** Number of calls to [TaskRunner.Backend.execute]. Guarded by `this`. */
  var executeCallCount = 0

  /** Guarded by [taskRunner]. */
  var nanoTime = 0L
    private set