*
 * @author Kevin Bourrillion
 * @author Louis Wasserman
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class TestCharacterListGenerator implements TestListGenerator<Character> {
  @Override
  public SampleElements<Character> samples() {
    return new Chars();
  }

  @Override
  public List<Character> create(Object... elements) {

 *
 * @author Regina O'Dell
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class TestUnhashableCollectionGenerator<T extends Collection<UnhashableObject>>
    implements TestCollectionGenerator<UnhashableObject> {
  @Override
  public SampleElements<UnhashableObject> samples() {
    return new Unhashables();
  }

  @Override
  public T create(Object... elements) {

   * as {@code execute} and {@code invokeAny}, are implemented in terms of calls to {@code
   * delegate.execute}. All other methods are forwarded unchanged to the delegate. This implies that
   * the returned {@code ListeningExecutorService} never calls the delegate's {@code submit}, {@code
   * invokeAll}, and {@code invokeAny} methods, so any special handling of tasks must be implemented

        import org.gradle.api.Project
        class TestPlugin1 implements Plugin<Project> {
          void apply(Project project) {}
        }
    """)

    private Class<?> plugin2Class = classLoader.parseClass("""
        import org.gradle.api.Plugin
        import org.gradle.api.Project
        class TestPlugin2 implements Plugin<Project> {
          void apply(Project project) {}
        }
    """)

controlled by that implementation.

3. If the %v verb is used with the # flag (%#v) and the operand
implements the [GoStringer] interface, that will be invoked.

If the format (which is implicitly %v for [Println] etc.) is valid
for a string (%s %q %x %X), or is %v but not %#v,
the following two rules apply:

4. If an operand implements the error interface, the Error method
will be invoked to convert the object to a string, which will then

    }

    @Override
    public <T> T newInstance(Class<? extends T> type, Object... parameters) throws ObjectInstantiationException {
        // If the plugin type is abstract, it likely has abstract methods that should be implemented
        // during class generation. In this case, we should use the decorated instantiator to create
        // the plugin instance.  Otherwise, we should use the injected instantiator to create the plugin

 * This can be used to implement guaranteed delivery mechanisms, where proper interrupt handling is up to the delegate.
 */
public final class InterruptibleRunnable implements Runnable {
    private final Lock stateLock = new ReentrantLock();
    private final Runnable delegate;
    private boolean interrupted;

        } else {
            return doIntersect(leftType.cast(right), rightType.cast(left), factory);
        }
    }

    /**
     * Intersects the given exclude specs.
     *
     * This method is meant to be implemented by subclasses realizing a specific intersection of types.
     *
     * @param left an exclude spec
     * @param right another exclude spec
     * @param factory the factory that can be used to create a new exclude spec

   *     instead.
   * @since 21.0
   */
  @Deprecated
  @Override
  public final boolean test(@CheckForNull T t, @CheckForNull T u) {
    return equivalent(t, u);
  }

  /**
   * Implemented by the user to determine whether {@code a} and {@code b} are considered equivalent,
   * subject to the requirements specified in {@link #equivalent}.
   *

			}
		}

	}

	if runtime.GOOS != "windows" {
		// skip below MkdirAll for windows since the "bind mount" logic is implemented differently in mount_wiondows.go
		if err := os.MkdirAll(dir, 0750); err != nil {
			klog.Errorf("mkdir failed on disk %s (%v)", dir, err)
			return err
		}
	}