*/
    public final int getDataSize() {
        return this.fileDataSize;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbBasicFileInfo#getSize()
     */
    @Override
    public long getSize() {
        return getDataSize();
    }

    /**
     * Gets the granted access rights.
     *
     * @return the grantedAccess
     */
    public final int getGrantedAccess() {

      @Override
      public int size() {
        return max(0, data.size() + delta);
      }

      @Override
      public T get(int index) {
        return data.get(index);
      }

      @Override
      public T set(int index, T element) {
        return data.set(index, element);
      }

      @Override
      public boolean add(T element) {

    public void setTargetRole(String value) {
        registerModifiedProperty("targetRole");
        this.targetRole = value;
    }

    public String getUpdatedBy() {
        checkSpecifiedProperty("updatedBy");
        return convertEmptyToNull(updatedBy);
    }

    public void setUpdatedBy(String value) {
        registerModifiedProperty("updatedBy");
        this.updatedBy = value;
    }

  @SuppressWarnings("unchecked")
  public static <K, V> ImmutableBiMap<K, V> of() {
    return (ImmutableBiMap<K, V>) RegularImmutableBiMap.EMPTY;
  }

  public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1) {
    checkEntryNotNull(k1, v1);
    return new SingletonImmutableBiMap<K, V>(k1, v1);
  }

  public static <K, V> ImmutableBiMap<K, V> of(K k1, V v1, K k2, V v2) {

  }

  public void testParse_maximumWeightRepeated() {
    assertThrows(IllegalArgumentException.class, () -> parse("maximumWeight=10, maximumWeight=20"));
  }

  public void testParse_maximumSizeAndMaximumWeight() {
    assertThrows(IllegalArgumentException.class, () -> parse("maximumSize=10, maximumWeight=20"));
  }

  public void testParse_concurrencyLevel() {

    public void setId_Equal(String id) {
        setId_Term(id, null);
    }

    public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setId_Term(id, opLambda);
    }

    public void setId_Term(String id) {
        setId_Term(id, null);
    }

  }

  public void testNewEnumSet_collection() {
    Set<SomeEnum> set = ImmutableSet.of(SomeEnum.B, SomeEnum.C);
    assertEquals(set, newEnumSet(set, SomeEnum.class));
  }

  public void testNewEnumSet_iterable() {
    Set<SomeEnum> set = ImmutableSet.of(SomeEnum.A, SomeEnum.B, SomeEnum.C);
    assertEquals(set, newEnumSet(unmodifiableIterable(set), SomeEnum.class));
  }

  public void testNewHashSetEmpty() {

    assertEquals(emptyList(), bigger);
  }

  public void testNewArrayListWithExpectedSize_negative() {
    assertThrows(IllegalArgumentException.class, () -> newArrayListWithExpectedSize(-1));
  }

  public void testNewArrayListVarArgs() {
    ArrayList<Integer> list = Lists.newArrayList(0, 1, 1);
    assertEquals(SOME_COLLECTION, list);
  }

  public void testComputeArrayListCapacity() {

    }
  }

  public void testTailClosedEntrySet() {
    testSubMultisetEntrySet(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailClosedSize() {
    testSubMultisetSize(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailClosedDistinctElements() {
    testSubMultisetDistinctElements(SubMultisetSpec.TAIL_CLOSED);
  }

  public void testTailOpenEntrySet() {

            this.sourceMap = new HashMap<>();
        }

        @Override
        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        @Override
        public Long getVersionNo() {
            return versionNo;
        }

        public void setVersionNo(Long versionNo) {
            this.versionNo = versionNo;
        }