assertThat(myBean.getURL(), is(notNullValue()));
    }

    /**
     *
     */
    public void testConvertWithString() {
        final BeanDesc beanDesc = BeanDescFactory.getBeanDesc(MyDto.class);
        final PropertyDesc pd = beanDesc.getPropertyDesc("myEnum");
        final MyDto dto = new MyDto();
        pd.setValue(dto, "ONE");
        assertEquals(MyEnum.ONE, dto.myEnum);

        public V getValue() {
          return ArrayMap.this.getValue(index);
        }

        @Override
        @ParametricNullness
        public V setValue(@ParametricNullness V value) {
          return ArrayMap.this.setValue(index, value);
        }
      };
    }

    @Override
    Iterator<Entry<K, V>> entryIterator() {
      return new AbstractIndexedListIterator<Entry<K, V>>(size()) {

      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override
  public Set<Entry<Class<? extends @NonNull B>, B>> entrySet() {

        assertNotNull(task);
        assertNotNull(task.getValue1());
        assertNotNull(task.getValue2());
        assertNotNull(task.getValue3());
        assertEquals("task-id", task.getValue1());
        assertEquals(path, task.getValue2());
        assertEquals("application/pdf", task.getValue3());
    }

    public void test_createTask_withNullPath() {
        // Test task creation with null path

      assertEquals(2 * i, (int) inverse.get(2 * i - 1));
    }
    Set<Entry<Integer, Integer>> entries = bimap.entrySet();
    for (Entry<Integer, Integer> entry : entries) {
      entry.setValue(entry.getValue() + 2 * N);
    }
    for (int i = 0; i < N; i++) {
      assertEquals(2 * N + 2 * i - 1, (int) bimap.get(2 * i));
    }
  }

  public void testBiMapEntrySetIteratorRemove() {

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

  @Override
  @ParametricNullness
  @CanIgnoreReturnValue
  public V setValue(@ParametricNullness V value) {
    return delegate().setValue(value);
  }

  @Override
  public boolean equals(@Nullable Object object) {
    return delegate().equals(object);
  }

  @Override
  public int hashCode() {

    }

    @Override
    @ParametricNullness
    public K setValue(@ParametricNullness K key) {
      updateIndex();
      if (index == ABSENT) {
        biMap.putInverse(value, key, false);
        return unsafeNull(); // see EntryForKey.setValue()
      }
      K oldKey = uncheckedCastNullableTToT(biMap.keys[index]); // see EntryForKey.setValue()
      if (Objects.equals(oldKey, key)) {
        return key;

        List<LabelType> labelTypeList = new ArrayList<>();

        LabelType labelType1 = new LabelType();
        labelType1.setName("Test Label 1");
        labelType1.setValue("test1");
        labelType1.setPermissions(new String[0]);
        labelType1.setVirtualHost("");
        // Locale is derived from value, not set directly
        labelType1.setIncludedPaths("/test.*");

      int entryIndex, @ParametricNullness K key, @ParametricNullness V value, int hash, int mask) {
    this.setEntry(entryIndex, CompactHashing.maskCombine(hash, UNSET, mask));
    this.setKey(entryIndex, key);
    this.setValue(entryIndex, value);
  }

  /** Resizes the entries storage if necessary. */
  private void resizeMeMaybe(int newSize) {
    int entriesSize = requireEntries().length;
    if (newSize > entriesSize) {

                final String headerValue = req.getHeader(host.getValue1());
                if (host.getValue2().equalsIgnoreCase(headerValue)) {
                    return func.apply(host.getValue3());
                }
            }
            return defaultValue;
        }).orElse(defaultValue);
    }

    /**
     * Gets all configured virtual host paths.
     *