return ImmutableList.this.get(index);
      }
    };
  }

  @Override
  public ImmutableList<E> asList() {
    return this;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    return Lists.equalsImpl(this, obj);
  }

  @Override
  public int hashCode() {
    return Lists.hashCodeImpl(this);
  }

  public ImmutableList<E> reverse() {

                    this.requireMic = true;
                }
                this.firstResponse = false;
            } else if (targ.getMechanism() != null && !targ.getMechanism().equals(this.selectedMech)) {
                throw new SmbException("Server switched mechanism");
            }
            inputToken = targ.getMechanismToken();
        } else {

        if (dataClass == null) {
            return super.getData(accessResultData);
        }

        final Map<String, Object> dataMap = XmlUtil.getDataMap(accessResultData);
        if (Map.class.equals(dataClass)) {
            return dataMap;
        }

        try {
            final Object obj = dataClass.getDeclaredConstructor().newInstance();
            BeanUtil.copyMapToBean(dataMap, obj);

Les validations numériques fonctionnent également pour les valeurs `float`.

C'est ici qu'il devient important de pouvoir déclarer <abbr title="greater than"><code>gt</code></abbr> et pas seulement <abbr title="greater than or equal"><code>ge</code></abbr>. Avec cela, vous pouvez exiger, par exemple, qu'une valeur doit être supérieure à `0`, même si elle est inférieure à `1`.

Ainsi, `0.5` serait une valeur valide. Mais `0.0` ou `0` ne le serait pas.

		}
		if err == nil {
			// Verify that checksums of staleDisks
			// match expected values
			for i := range staleWriters {
				if staleWriters[i] == nil {
					continue
				}
				if !bytes.Equal(bitrotWriterSum(staleWriters[i]), bitrotWriterSum(writers[i])) {
					t.Errorf("Test %d: heal returned different bitrot checksums", i)
				}
			}
		}
	}

      this.value = value;
    }

    @Override
    public int compareTo(ClassWithTerribleHashCode that) {
      return Integer.compare(this.value, that.value);
    }

    @Override
    public boolean equals(@Nullable Object x) {
      return x instanceof ClassWithTerribleHashCode
          && ((ClassWithTerribleHashCode) x).value == value;
    }

    @Override
    public int hashCode() {
      return 23;

            <![CDATA[
    /**
     * @see java.lang.Object#equals(java.lang.Object)
     */
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        } else if (o instanceof Extension e) {
            return java.util.Objects.equals(e.getArtifactId(), getArtifactId())
                && java.util.Objects.equals(e.getGroupId(), getGroupId())

    public Object load(Object key) {
      return new Object();
    }

    @Override
    public int hashCode() {
      return 42;
    }

    @Override
    public boolean equals(@Nullable Object o) {
      return o instanceof SerializableCacheLoader;
    }
  }

  private static class SerializableRemovalListener<K, V>
      implements RemovalListener<K, V>, Serializable {

<p>
Comparison operators compare two operands and yield an untyped boolean value.
</p>

<pre class="grammar">
==    equal
!=    not equal
&lt;     less
&lt;=    less or equal
&gt;     greater
&gt;=    greater or equal
</pre>

<p>
In any comparison, the first operand
must be <a href="#Assignability">assignable</a>
to the type of the second operand, or vice versa.

         *
         * @param h1 the first hour
         * @param m1 the first minute
         * @param h2 the second hour
         * @param m2 the second minute
         * @return positive if first time is earlier, 0 if equal, negative if later
         */
        protected int compareTime(final int h1, final int m1, final int h2, final int m2) {
            if (h1 < h2) {
                return 1;
            }