*/
public final class PropertyConfiguration extends BaseConfiguration implements Configuration {

    /**
     * @param p
     *            read from properties
     * @throws CIFSException
     * 
     */
    public PropertyConfiguration ( Properties p ) throws CIFSException {
        this.useBatching = Config.getBoolean(p, "jcifs.smb.client.useBatching", false);
        this.useUnicode = Config.getBoolean(p, "jcifs.smb.client.useUnicode", true);

    //
    // p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    @Test
    void testDependencyManagementDoesNotOverrideScopeOfCurrentArtifact() throws Exception {
        File localRepo = getLocalRepositoryPath();

        File pom0 = new File(localRepo, "p0/pom.xml");
        File pom0Basedir = pom0.getParentFile();
        File pom1 = new File(pom0Basedir, "p1/pom.xml");

    assertThat(request.method).isEqualTo("GET")
    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(request.body).isNull()
  }

  @Test
  @Throws(IOException::class)
  fun put() {
    val request = fromArgs("-X", "PUT", "-d", "foo", "http://example.com").createRequest()
    assertThat(request.method).isEqualTo("PUT")

import static org.apache.maven.cling.invoker.Utils.createInterpolator;

public class CommonsCliEncryptOptions extends CommonsCliOptions implements EncryptOptions {
    public static CommonsCliEncryptOptions parse(String[] args) throws ParseException {
        CLIManager cliManager = new CLIManager();
        return new CommonsCliEncryptOptions(Options.SOURCE_CLI, cliManager, cliManager.parse(args));
    }

    public ArtifactVersion getApplicationVersion() {
        return applicationVersion;
    }

    public void initialize() throws InitializationException {
        String mavenVersion = rtInfo.getMavenVersion();

        if (mavenVersion == null || mavenVersion.isEmpty()) {
            throw new InitializationException("Unable to read Maven version from maven-core");
        }

  }

  @Test
  fun streamingPartHasNoLength() {
    class StreamingBody(private val body: String) : RequestBody() {
      override fun contentType(): MediaType? {
        return null
      }

      @Throws(IOException::class)
      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8(body)
      }
    }

    val expected =
      """
      |--123
      |
      |Quick
      |--123

    final Thread interruptingThread = new Thread(interruptingTask);
    interruptingThread.start();
    tearDownAccepter.addTearDown(
        new TearDown() {
          @Override
          public void tearDown() throws Exception {
            interruptingTask.stopInterrupting();
            interruptingThread.interrupt();
            joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
            Thread.interrupted();

     *
     * @param version The model version to retrieve the super POM for (e.g. "4.0.0"), must not be {@code null}.
     * @return The super POM, never {@code null}.
     * @throws SuperPomProviderException if the super POM could not be retrieved
     */
    @Nonnull
    Model getSuperPom(@Nonnull String version);

        super(messageBuilderFactory, secDispatcher);
    }

    @Override
    protected int doExecute(DefaultEncryptInvoker.LocalContext context) throws Exception {
        String cleartext = context.reader.readLine("Enter the password to encrypt: ", '*');
        context.terminal.writer().println(secDispatcher.encrypt(cleartext, null));
        return OK;
    }

public class TextExtractorTest extends PlainTestCase {
    private static final Logger logger = LoggerFactory.getLogger(TextExtractorTest.class);

    public TextExtractor textExtractor;

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        StandardCrawlerContainer container = new StandardCrawlerContainer().singleton("textExtractor", TextExtractor.class);
        textExtractor = container.getComponent("textExtractor");