m.Set(driveUsedBytes, float64(drive.UsedSpace), labels...)
	m.Set(driveFreeBytes, float64(drive.AvailableSpace), labels...)
	m.Set(driveTotalBytes, float64(drive.TotalSpace), labels...)
	m.Set(driveUsedInodes, float64(drive.UsedInodes), labels...)
	m.Set(driveFreeInodes, float64(drive.FreeInodes), labels...)
	m.Set(driveTotalInodes, float64(drive.UsedInodes+drive.FreeInodes), labels...)

        addrIndexField.setAccessible(true);
        addrIndexField.set(nameQueryResponse, 0);

        // Set 'recordName' for NbtAddress constructor
        Field recordNameField = NameServicePacket.class.getDeclaredField("recordName");
        recordNameField.setAccessible(true);
        Name mockRecordName = new Name(mockConfig);
        recordNameField.set(nameQueryResponse, mockRecordName);

  }

  private static Set<Feature<?>> computeReserializedMapFeatures(Set<Feature<?>> mapFeatures) {
    Set<Feature<?>> derivedFeatures = copyToSet(mapFeatures);
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
    derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
    return derivedFeatures;
  }

  private static Set<Feature<?>> computeEntrySetFeatures(Set<Feature<?>> mapFeatures) {

		metricsLogIf(ctx, err)
		return err
	}

	m.Set(memTotal, float64(memMetrics.Total))
	m.Set(memUsed, float64(memMetrics.Used))
	usedPerc := float64(memMetrics.Used) * 100 / float64(memMetrics.Total)
	m.Set(memUsedPerc, usedPerc)
	m.Set(memFree, float64(memMetrics.Free))
	m.Set(memBuffers, float64(memMetrics.Buffers))
	m.Set(memCache, float64(memMetrics.Cache))
	m.Set(memShared, float64(memMetrics.Shared))

  }

  private abstract static class AtomicHelper {
    /** Performs an atomic compare-and-set of {@link AggregateFutureState#seenExceptionsField}. */
    abstract void compareAndSetSeenExceptions(
        AggregateFutureState<?> state, @Nullable Set<Throwable> expect, Set<Throwable> update);

    /** Performs an atomic decrement-and-get of {@link AggregateFutureState#remainingField}. */

     */
    @CanIgnoreReturnValue
    protected boolean set(@Nullable V value) {
      boolean result = sync.set(value);
      if (result) {
        executionList.execute();
      }
      return result;
    }

    /**
     * Subclasses should invoke this method to set the result of the computation to an error, {@code
     * throwable}. This will set the state of the future to {@link OldAbstractFuture.Sync#COMPLETED}

						},
					},
				},
				nil,
				[][]uint64{{9, 9, 9}},
			},
			true,
		},
		{
			"/export/set{1...64}",
			endpointSet{
				[]ellipses.ArgPattern{
					[]ellipses.Pattern{
						{
							Prefix: "/export/set",
							Suffix: "",
							Seq:    getSequences(1, 64, 0),
						},
					},
				},
				nil,
				[][]uint64{{16, 16, 16, 16}},
			},

        Set<String> roleSet = new HashSet<>();
        roleQueryHelperImpl.processHeader(request, roleSet);
        return roleSet;
    }

    private Set<String> buildByCookie(final RoleQueryHelper roleQueryHelperImpl, final HttpServletRequest request) {
        Set<String> roleSet = new HashSet<>();
        roleQueryHelperImpl.processCookie(request, roleSet);
        return roleSet;
    }

  }

  @Override
  public Set<V> get(@ParametricNullness K key) {
    return (Set<V>) super.get(key);
  }

  @Override
  public Set<V> removeAll(@Nullable Object key) {
    return (Set<V>) super.removeAll(key);
  }

  @Override
  public Set<V> replaceValues(@ParametricNullness K key, Iterable<? extends V> values) {
    return (Set<V>) super.replaceValues(key, values);
  }

  @Override

      Set<E> delegate, Supplier<Boolean> validator, Supplier<String> errorMessage) {
    return new InvalidatableSet<>(
        checkNotNull(delegate), checkNotNull(validator), checkNotNull(errorMessage));
  }

  @Override
  protected Set<E> delegate() {
    validate();
    return delegate;
  }

  private InvalidatableSet(
      Set<E> delegate, Supplier<Boolean> validator, Supplier<String> errorMessage) {