import org.gradle.api.Incubating
import spock.lang.Specification
import spock.lang.TempDir

import javax.inject.Inject

class PublicAPIRulesTest extends Specification {
    private final static String TEST_INTERFACE_NAME = 'org.gradle.api.ApiTest'
    private final static String TEST_INTERFACE_SIMPLE_NAME = 'ApiTest'

    @TempDir
    File tmp
    File sourceFile

    BinaryCompatibilityRepository repository

      tasks.remove().run();
    }

    void runAll() {
      while (hasNext()) {
        runNext();
      }
    }
  }

  private FakeExecutor fakePool;
  private SequentialExecutor e;

  @Override
  public void setUp() {
    fakePool = new FakeExecutor();
    e = new SequentialExecutor(fakePool);
  }

 *
 * @author mbechler
 */
public final class PropertyConfiguration extends BaseConfiguration implements Configuration {

    private boolean useMultiChannelExplicitlySet = false;
    private boolean channelBindingPolicyExplicitlySet = false;

    /**
     * Create a configuration backed by properties
     *

     *
     * @return the XmlService instance
     * @throws IllegalStateException if no implementation is found
     */
    private static XmlService getService() {
        return Holder.INSTANCE;
    }

    /** Holder class for lazy initialization of the default instance */
    private static final class Holder {
        static final XmlService INSTANCE = ServiceLoader.load(XmlService.class)
                .findFirst()

```
--sftp="address=:3022"
```

### TLS (FTP)

Unlike SFTP server, FTP server is insecure by default. To operate under TLS mode, you need to provide certificates via

```
--ftp="tls-private-key=path/to/private.key" --ftp="tls-public-cert=path/to/public.crt"
```

> NOTE: if MinIO distributed setup is already configured to run under TLS, FTP will automatically use the relevant

            assertFalse(
                    ModelVersionUtils.isValidModelVersion(version), "Should reject " + description + ": " + version);
        }

        private static Stream<Arguments> provideInvalidVersions() {
            return Stream.of(
                    Arguments.of(null, "null version"),
                    Arguments.of("", "empty version"),

        return OptionalThing.of(new FessUserBean(new TestUser(name, permissions)));
    }

    static class TestUser implements FessUser {

        private static final long serialVersionUID = 1L;

        private String name;

        private String[] permissions;

        TestUser(String name, String[] permissions) {
            this.name = name;
            this.permissions = permissions;

        }

@NullUnmarked
@AndroidIncompatible // test-suite builders
public class MultimapsCollectionTest extends TestCase {

  private static final Feature<?>[] FOR_MAP_FEATURES_ONE = {
    CollectionSize.ONE,
    ALLOWS_NULL_VALUES,
    SUPPORTS_REMOVE,
    CollectionFeature.SUPPORTS_ITERATOR_REMOVE
  };

  private static final Feature<?>[] FOR_MAP_FEATURES_ANY = {
    CollectionSize.ANY,
    ALLOWS_NULL_VALUES,
    SUPPORTS_REMOVE,

                MapFeature.ALLOWS_ANY_NULL_QUERIES,
                CollectionFeature.KNOWN_ORDER)
            .createTestSuite());
    return suite;
  }

  private static final ImmutableList<Range<Integer>> RANGES;
  private static final int MIN_BOUND = -1;
  private static final int MAX_BOUND = 1;

  static {
    ImmutableList.Builder<Range<Integer>> builder = ImmutableList.builder();

    builder.add(Range.<Integer>all());

 *       {@code hashCode} implementation, it should cache it itself.
 * </ul>
 *
 * <h4>Example usage</h4>
 *
 * {@snippet :
 * class Foo {
 *   private static final ImmutableSet<String> RESERVED_CODES =
 *       ImmutableSet.of("AZ", "CQ", "ZX");
 *
 *   private final ImmutableSet<String> codes;
 *
 *   public Foo(Iterable<String> codes) {
 *     this.codes = ImmutableSet.copyOf(codes);