* you want to throw away the class loader. For example, dynamically reloading a web application or
 * unloading an OSGi bundle.
 *
 * <p>{@code com.google.common.base.FinalizableReferenceQueue} loads this class in its own class
 * loader. That way, this class doesn't prevent the main class loader from getting garbage
 * collected, and this class can detect when the main class loader has been garbage collected and
 * stop itself.

    Reflection.initialize(A.class);
    assertEquals(1, classesInitialized);

    Reflection.initialize(
        A.class, // Already initialized (above)
        B.class, C.class);
    assertEquals(3, classesInitialized);
  }

  public void testNullPointers() {
    new NullPointerTester().testAllPublicStaticMethods(Reflection.class);
  }

            when(mockTreeHandle.send(any(SmbComDelete.class), any(SmbComBlankResponse.class))).thenReturn(mock(SmbComBlankResponse.class));

            // Act
            smbFile.delete();

            // Assert
            verify(mockTreeHandle).send(any(SmbComDelete.class), any(SmbComBlankResponse.class));
        }

        @Test

import org.codelibs.core.exception.MethodNotStaticRuntimeException;
import org.codelibs.core.lang.MethodUtil;

/**
 * Implementation class of {@link MethodDesc}.
 *
 * @author koichik
 */
public class MethodDescImpl implements MethodDesc {

    /** The {@link BeanDesc} of the class that owns this method */
    protected final BeanDesc beanDesc;

    /** The method */
    protected final Method method;

      CallStart::class,
      ProxySelectStart::class,
      ProxySelectEnd::class,
      DnsStart::class,
      DnsEnd::class,
      ConnectStart::class,
      ConnectEnd::class,
      ConnectionAcquired::class,
      RequestHeadersStart::class,
      RequestHeadersEnd::class,
      ResponseFailed::class,
      RetryDecision::class,
      ConnectionReleased::class,

        MapIsEmptyTester.class,
        MapMergeTester.class,
        MapPutTester.class,
        MapPutAllTester.class,
        MapPutIfAbsentTester.class,
        MapRemoveTester.class,
        MapRemoveEntryTester.class,
        MapReplaceTester.class,
        MapReplaceAllTester.class,
        MapReplaceEntryTester.class,
        MapSerializationTester.class,
        MapSizeTester.class,

        Types.newParameterizedTypeWithOwner(null, Entry.class, String.class, Integer.class));
  }

  public void testNewParameterizedType_invalidTypeParameters() {
    assertThrows(
        IllegalArgumentException.class,
        () -> Types.newParameterizedTypeWithOwner(Map.class, Entry.class, String.class));
  }

        }
    }

    private void handleChecksumFailure(String checksumPolicy, String message, Throwable cause)
            throws ChecksumFailedException {
        if (ArtifactRepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy)) {
            throw new ChecksumFailedException(message, cause);
        } else if (!ArtifactRepositoryPolicy.CHECKSUM_POLICY_IGNORE.equals(checksumPolicy)) {

  }

  private interface Sample {
    String sleepThenReturnInput(String input);

    void sleepThenThrowException() throws SampleException;
  }

  @SuppressWarnings("serial")
  private static class SampleException extends Exception {}

  @SuppressWarnings("serial")
  private static class SampleRuntimeException extends RuntimeException {}

//	}})
func (db *DB) Order(value interface{}) (tx *DB) {
	tx = db.getInstance()

	switch v := value.(type) {
	case clause.OrderBy:
		tx.Statement.AddClause(v)
	case clause.OrderByColumn:
		tx.Statement.AddClause(clause.OrderBy{
			Columns: []clause.OrderByColumn{v},
		})
	case string:
		if v != "" {
			tx.Statement.AddClause(clause.OrderBy{
				Columns: []clause.OrderByColumn{{