if (projectProperties != null) {
            this.projectProperties = projectProperties.entrySet().stream()
                    .collect(collectingAndThen(
                            toMap(e -> String.valueOf(e.getKey()), e -> String.valueOf(e.getValue())),
                            Collections::unmodifiableMap));
        } else {
            this.projectProperties = Collections.emptyMap();
        }

        return this;

          V oldValue = (V) values[entryIndex];

          values[entryIndex] = value;
          accessEntry(entryIndex);
          return oldValue;
        }
        next = CompactHashing.getNext(entry, mask);
        bucketLength++;
      } while (next != UNSET);

      if (bucketLength >= MAX_HASH_BUCKET_LENGTH) {
        return convertToHashFloodingResistantImplementation().put(key, value);
      }

        JsonPath jsonPath = JsonPath.from(response.asString());
        assertTrue(jsonPath.getBoolean("response.created"));
        assertEquals(0, jsonPath.getInt("response.status"));
        return jsonPath.get("response.id");
    }

    protected static void deleteLabel(String id) {
        checkMethodBase(new HashMap<>()).delete("/api/admin/labeltype/setting/" + id);
    }

          .containsAtLeastElementsIn(EnumSet.complementOf(EnumSet.of(UNNECESSARY)));
      for (Map.Entry<RoundingMode, Double> entry : expectedValues.entrySet()) {
        RoundingMode mode = entry.getKey();
        Double expectation = entry.getValue();
        assertWithMessage("roundToDouble(%s, %s)", input, mode)
            .that(BigDecimalMath.roundToDouble(input, mode))
            .isEqualTo(expectation);
      }

        /**
         * @return Object
         */
        public Object isDdd() {
            return null;
        }

        /**
         * @return String
         */
        public String getEee() {
            return null;
        }

        /**
         * @param eee
         */
        public void setEee(final String eee) {
        }

        /**
         * @return int

                    NavigableMap<String, String> map = new SafeTreeMap<>();
                    for (Entry<String, String> entry : entries) {
                      map.put(entry.getKey(), entry.getValue());
                    }
                    return new StandardImplForwardingNavigableMap<>(map);
                  }
                })
            .named(

    Map<Element, Element> map = mapToTest;

    boolean dummy = false;
    for (int i = 0; i < reps; i++) {
      for (Map.Entry<Element, Element> entry : map.entrySet()) {
        dummy ^= entry.getKey() != entry.getValue();
      }
    }
    return dummy;
  }

  @Benchmark
  boolean iterateWithKeySetAndGet(int reps) {
    Map<Element, Element> map = mapToTest;

    boolean dummy = false;

      BiMap<Country, String> result = EnumHashBiMap.create(Country.class);
      for (Object o : entries) {
        Entry<Country, String> entry = (Entry<Country, String>) o;
        result.put(entry.getKey(), entry.getValue());
      }
      return result;
    }

    @Override
    public SampleElements<Entry<Country, String>> samples() {
      return new SampleElements<>(

import jcifs.smb1.Config;
import jcifs.smb1.util.Hexdump;

abstract class SmbComTransaction extends ServerMessageBlock implements Enumeration {

    private static final int DEFAULT_MAX_DATA_COUNT =
            Config.getInt("jcifs.smb1.smb.client.transaction_buf_size", SmbComTransaction.TRANSACTION_BUF_SIZE) - 512;

    // relative to headerStart
    private static final int PRIMARY_SETUP_OFFSET = 61;

        assertNotNull(e.getMessage()); // Should have an error message
    }

    @Test
    void testGetters() {
        // Simple test for getter methods
        NtlmContext context = new NtlmContext(mockAuth, true);
        assertFalse(context.isEstablished());
        assertNull(context.getServerChallenge());
        assertNull(context.getSigningKey());