* that tests equivalence using their lengths:
   *
   * {@snippet :
   * equiv.wrap("a").equals(equiv.wrap("b")) // true
   * equiv.wrap("a").equals(equiv.wrap("hello")) // false
   * }
   *
   * <p>Note in particular that an equivalence wrapper is never equal to the object it wraps.
   *
   * {@snippet :
   * equiv.wrap(obj).equals(obj) // always false
   * }
   *
   * @since 10.0
   */

public final String calculateUserAgent(); } org/gradle/wrapper/GradleUserHomeLookup.class package org.gradle.wrapper; public abstract class GradleUserHomeLookup { public static final String DEFAULT_GRADLE_USER_HOME; static void <clinit>(); } org/gradle/wrapper/GradleWrapperMain.class package org.gradle.wrapper; public class GradleWrapperMain { public static void main(String[]); } org/gradle/wrapper/Install$1.class package org.gradle.wrapper; public final class Install$1 implements java.util.concurrent.Callable...

        assertNotNull(connection2, "Second connection should not be null.");
        assertTrue(connection1 instanceof NtlmHttpURLConnection, "First connection should be wrapped.");
        assertTrue(connection2 instanceof NtlmHttpURLConnection, "Second connection should be wrapped.");
    }

            // Wrapper but not wrapping a DosFileFilter
            SmbFileFilter nonDosFilter = mock(SmbFileFilter.class);
            Object wrapper = newPrivateInner("ResourceFilterWrapper", new Class<?>[] { SmbFileFilter.class }, nonDosFilter);

            Object unwrapped = invokePrivate(SmbEnumerationUtil.class, "unwrapDOSFilter", new Class<?>[] { ResourceFilter.class }, wrapper);
            assertNull(unwrapped);

            }
            return copyInternal((FileInputStream) in, wrap(out));
        }
        if (out instanceof FileOutputStream) {
            return copyInternal(wrap(in), (FileOutputStream) out);
        }
        return copyInternal(wrap(in), wrap(out));
    }

    // ////////////////////////////////////////////////////////////////
    // from InputStream to Writer

                throw new RuntimeException("Wrapper exception", cause);
            }
        };
        ComponentUtil.register(mockSearchLogHelper, "searchLogHelper");

        // Execute the job
        String result = aggregateLogJob.execute();

        // Verify result contains the wrapper exception message
        assertNotNull(result);
        assertTrue(result.contains("Wrapper exception"));

        ParameterNotInstantiableException.class,
        () -> new ClassSanityTester().doTestEquals(SetWrapper.class));
  }

  private abstract static class Wrapper {
    private final Object wrapped;

    Wrapper(Object wrapped) {
      this.wrapped = checkNotNull(wrapped);
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      // In general getClass().isInstance() is bad for equals.

        assertNotNull(result);
        // PhraseQueryCommand returns DefaultQueryBuilder which wraps either Bool or DisMax
        assertTrue(result instanceof DefaultQueryBuilder);
        // The boost is applied internally to the wrapped queries, not necessarily to the DefaultQueryBuilder itself
    }

    public void test_execute_withBooleanQuery() {

      return Iterators.pollNext(descendingIterator());
    }

    private NavigableSet<V> wrap(NavigableSet<V> wrapped) {
      return new WrappedNavigableSet(key, wrapped, (getAncestor() == null) ? this : getAncestor());
    }

    @Override
    public NavigableSet<V> descendingSet() {
      return wrap(getSortedSetDelegate().descendingSet());
    }

    @Override

            // Wrap in another exception
            TransportException wrapper = new TransportException("Wrapper", original);

            assertEquals("Wrapper", wrapper.getMessage());
            assertEquals(original, wrapper.getRootCause());
            assertEquals(originalMessage, ((TransportException) wrapper.getRootCause()).getMessage());
        }
    }