}
        return s1.indexOf(s2) >= 0;
    }

    /**
     * Returns whether two strings are equal. If both are null, returns <code>true</code>.
     *
     * @param target1
     *            the first string
     * @param target2
     *            the second string
     * @return true if the strings are equal, false otherwise
     */
    public static boolean equals(final String target1, final String target2) {

public final class ForwardingWrapperTester {

  private boolean testsEquals = false;

  /**
   * Asks for {@link Object#equals} and {@link Object#hashCode} to be tested. That is, forwarding
   * wrappers of equal instances should be equal.
   */
  @CanIgnoreReturnValue
  public ForwardingWrapperTester includingEquals() {
    this.testsEquals = true;
    return this;
  }

  /**

	bucket := getRandomBucketName()
	// create bucket.
	err = obj.MakeBucket(b.Context(), bucket, MakeBucketOptions{})
	if err != nil {
		b.Fatal(err)
	}

	// get text data generated for number of bytes equal to object size.
	textData := generateBytesData(objSize)
	// generate md5sum for the generated data.
	// md5sum of the data to written is required as input for PutObject.

	md5hex := getMD5Hash(textData)
	sha256hex := ""

        @Test
        @DisplayName("Should be equal when MIDs match")
        void testEquals() {
            TestServerMessageBlock2 other = new TestServerMessageBlock2(mockConfig);
            testMessage.setMid(12345L);
            other.setMid(12345L);

            assertTrue(testMessage.equals(other));
        }

        @Test
        @DisplayName("Should not be equal when MIDs differ")

 * a {@link RoundingMode}.
 */
@GwtIncompatible
abstract class ToDoubleRounder<X extends Number & Comparable<X>> {
  /**
   * Returns x rounded to either the greatest double less than or equal to the precise value of x,
   * or the least double greater than or equal to the precise value of x.
   */
  abstract double roundToDoubleArbitrarily(X x);

  /** Returns the sign of x: either -1, 0, or 1. */
  abstract int sign(X x);

   * Atomically sets the value to the given updated value if the current value is <a
   * href="#bitEquals">bitwise equal</a> to the expected value.
   *
   * @param expect the expected value
   * @param update the new value
   * @return {@code true} if successful. False return indicates that the actual value was not
   *     bitwise equal to the expected value.
   */
  public final boolean compareAndSet(double expect, double update) {

      Collection<V> result = unfiltered.asMap().get(key);
      if (result == null) {
        return null;
      }
      @SuppressWarnings("unchecked") // key is equal to a K, if not a K itself
      K k = (K) key;
      result = filterCollection(result, new ValuePredicate(k));
      return result.isEmpty() ? null : result;
    }

    @Override

	}

	for k, v := range tags {
		if string(removeSettingFromTag(reflect.StructTag(k), "column")) != v {
			t.Errorf("%v after removeSettingFromTag should equal %v, but got %v", k, v, removeSettingFromTag(reflect.StructTag(k), "column"))
		}
	}

	}

	ns := NamingStrategy{}
	for key, value := range maps {
		if ns.toDBName(key) != value {
			t.Errorf("%v toName should equal %v, but got %v", key, value, ns.toDBName(key))
		}
	}

	maps = map[string]string{
		"x":                              "X",
		"user_restrictions":              "UserRestriction",

   */
  protected abstract @Nullable Object handleInvocation(
      Object proxy, Method method, @Nullable Object[] args) throws Throwable;

  /**
   * By default delegates to {@link Object#equals} so instances are only equal if they are
   * identical. {@code proxy.equals(argument)} returns true if:
   *
   * <ul>
   *   <li>{@code proxy} and {@code argument} are of the same type