@Override
    public int hashCode() {
      synchronized (mutex) {
        return delegate().hashCode();
      }
    }

    @Override
    public K getKey() {
      synchronized (mutex) {
        return delegate().getKey();
      }
    }

    @Override
    public V getValue() {
      synchronized (mutex) {
        return delegate().getValue();
      }
    }

HSPLandroidx/arch/core/internal/SafeIterableMap$Entry;-><init>(Ljava/lang/Object;Ljava/lang/Object;)V
HSPLandroidx/arch/core/internal/SafeIterableMap$Entry;->getKey()Ljava/lang/Object;
HSPLandroidx/arch/core/internal/SafeIterableMap$Entry;->getValue()Ljava/lang/Object;
HSPLandroidx/arch/core/internal/SafeIterableMap$IteratorWithAdditions;-><init>(Landroidx/arch/core/internal/SafeIterableMap;)V

        }

        @Test
        @DisplayName("Should get and set read size")
        void testReadSizeProperty() {
            testMessage.setReadSize(1024);
            // No getter for readSize, but it's used internally in decode
        }

        @Test
        @DisplayName("Should check if async")
        void testAsyncProperty() {
            assertFalse(testMessage.isAsync());

                    continue;
                }
                counter++;
                final Map<String, Object> localDataMap =
                        dataMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
                if (deleteUrlList.contains(crawlRequest.getUrl())) {
                    deleteDocuments(); // delete before indexing
                }
                try {

        // N.B. There will only be an entry in the map if the service has started
        for (Entry<Service, Stopwatch> entry : startupTimers.entrySet()) {
          Service service = entry.getKey();
          Stopwatch stopwatch = entry.getValue();
          if (!stopwatch.isRunning() && !(service instanceof NoOpService)) {
            loadTimes.add(Maps.immutableEntry(service, stopwatch.elapsed(MILLISECONDS)));

            assertEquals(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, response.getContextType());
        }
    }

    @Nested
    @DisplayName("Getter Tests")
    class GetterTests {

        @Test
        @DisplayName("Should return hash algorithms correctly")
        void testGetHashAlgos() {
            int[] hashAlgos = { 0x01, 0x02, 0x03 };

                    if (fields != null) {
                        docMap.putAll(fields.entrySet()
                                .stream()
                                .collect(Collectors.toMap(Entry::getKey, e -> (Object) e.getValue().getValues())));
                    }

                    final ViewHelper viewHelper = ComponentUtil.getViewHelper();
                    if (viewHelper != null && !docMap.isEmpty()) {

    ImmutableSet.Builder<LocationInfo> builder = ImmutableSet.builder();
    for (Map.Entry<File, ClassLoader> entry : getClassPathEntries(classloader).entrySet()) {
      builder.add(new LocationInfo(entry.getKey(), entry.getValue()));
    }
    return builder.build();
  }

  /**
   * Represents a single location (a directory or a jar file) in the class path and is responsible

            assertEquals(expectedFlags, flags);
        }
    }

    @Nested
    @DisplayName("Getter and Setter Tests")
    class GetterSetterTests {

        @Test
        @DisplayName("setChallenge and getChallenge should work correctly")
        void testGetSetChallenge() {
            // Given

          }
        };
    for (Entry<Class<?>, Collection<Object>> entry : distinctValues.asMap().entrySet()) {
      generator.addSampleInstances((Class) entry.getKey(), entry.getValue());
    }
    return generator;
  }

  private static @Nullable Object generateDummyArg(Parameter param, FreshValueGenerator generator)
      throws ParameterNotInstantiableException {