org.cactoos.io.InputOf Java Examples

@Test
public void takesStatusOutOfHttpResponse() throws IOException {
    MatcherAssert.assertThat(
        new HtStatus(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        "Hello, dude!",
                        "How are you?"
                    )
                )
            )
        ).intValue(),
        Matchers.equalTo(HttpURLConnection.HTTP_OK)
    );
}
 

@Test
public void readsInputContent() {
    new Assertion<>(
        "Must read properties from an input",
        new PropertiesOf(
            new InputOf("greet=Hello, inner world!\nask=works fine?\n")
        ),
        new ScalarHasValue<>(
            new MatcherOf<Properties>(
                props -> {
                    return "Hello, inner world!".equals(
                        props.getProperty("greet")
                    );
                }
            )
        )
    ).affirm();
}
 

@Test
public void readsInputIntoText() throws Exception {
    new Assertion<>(
        "Can't read text from Input",
        new Synced(
            new TextOf(
                new InputOf("привет, друг!"),
                StandardCharsets.UTF_8
            )
        ).asString(),
        Matchers.allOf(
            Matchers.startsWith("привет, "),
            Matchers.endsWith("друг!")
        )
    ).affirm();
}
 

/**
 * Extract classes from passed Jar file.
 * @param path Jar file path
 * @throws IOException If fails
 */
private static void extractClasses(final Path path) throws IOException {
    try (JarFile jar = new JarFile(path.toFile())) {
        final Enumeration<JarEntry> entries = jar.entries();
        while (entries.hasMoreElements()) {
            final JarEntry entry = entries.nextElement();
            final Path item = path.getParent().resolve(entry.getName());
            if (entry.isDirectory()) {
                item.toFile().mkdir();
                continue;
            }
            final Path parent = item.getParent();
            if (!parent.toFile().exists()) {
                parent.toFile().mkdirs();
            }
            new LengthOf(
                new TeeInput(
                    new InputOf(jar.getInputStream(entry)),
                    item
                )
            ).intValue();
        }
    }
}
 

@Override
public Input code() {
    return new InputOf(
        new FormattedText(
            "%s\n\npublic interface %s {\n  %s\n}\n",
            "package eo;",
            this.name,
            new UncheckedText(
                new JoinedText(
                    "\n    ",
                    new Mapped<>(
                        mtd -> new UncheckedText(
                            new FormattedText("%s;", mtd.java())
                        ).asString(),
                        this.methods
                    )
                )
            ).asString().replace("\n", "\n  ")
        )
    );
}
 

@Test
public void skipsEverythingWhenEndingWithDelimiter() throws Exception {
    final String delimiter = "\r\n";
    MatcherAssert.assertThat(
        new TextOf(
            new SkipInput(
                new InputOf(
                    new Joined(
                        "",
                        "Hello dude! How are you?",
                        delimiter
                    )
                ),
                new BytesOf(delimiter)
            )
        ),
        new TextHasString("")
    );
}
 

@Test
public void skipsSomeBytes() throws Exception {
    final String prefix = "Hello dude!";
    final String suffix = "How are you?";
    final String delimiter = "\r";
    MatcherAssert.assertThat(
        new TextOf(
            new SkipInput(
                new InputOf(
                    new Joined(
                        delimiter,
                        prefix,
                        suffix
                    )
                ),
                new BytesOf(delimiter)
            )
        ),
        new TextHasString(suffix)
    );
}
 

@Test
public void takesDefaultContentType() {
    MatcherAssert.assertThat(
        new HtContentType(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "",
                        "Hello, dude!"
                    )
                )
            )
        ).value(),
        new IsEqual<>(new ListOf<>("application/octet-stream"))
    );
}
 

@Test
public void takesContentTypeOutOfHttpResponse() {
    MatcherAssert.assertThat(
        new HtContentType(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        "Hello, dude!"
                    )
                )
            )
        ).value(),
        new IsEqual<>(new ListOf<>("text/plain"))
    );
}
 

@Test
public void failsAfterMaxRetries() throws Exception {
    final String msg = "retry";
    final int max = 3;
    final AtomicInteger tries = new AtomicInteger(0);
    try {
        this.expected.expect(IllegalArgumentException.class);
        this.expected.expectMessage(msg);
        new HtRetryWire(
            input -> {
                if (tries.incrementAndGet() <= max) {
                    throw new IllegalArgumentException(msg);
                }
                return new InputOf("ignored");
            },
            max
        ).send(new InputOf("ignored"));
    } finally {
        MatcherAssert.assertThat(tries.get(), new IsEqual<>(max));
    }
}
 

@Test
public void eventuallySucceeds() throws Exception {
    final Text txt = new TextOf("out");
    final int max = 3;
    final AtomicInteger tries = new AtomicInteger(0);
    MatcherAssert.assertThat(
        new HtRetryWire(
            input -> {
                if (tries.incrementAndGet() < max) {
                    throw new IllegalArgumentException("retry");
                }
                return new InputOf(txt);
            },
            max
        ).send(new InputOf("ignored")),
        new InputHasContent(txt.asString())
    );
}
 

@Test
public void retriesMultipleTimesButNotMaxAttempts() {
    final int times = 3;
    final int max = times + 2;
    MatcherAssert.assertThat(
        t -> {
            final AtomicInteger tries = new AtomicInteger(0);
            new HtRetryWire(
                input -> {
                    if (tries.incrementAndGet() < t) {
                        throw new IllegalArgumentException("retry");
                    }
                    return new InputOf("ignored");
                },
                max
            ).send(new InputOf("ignored"));
            return tries.get();
        },
        new FuncApplies<>(times, times)
    );
}
 

@Override
public InputStream stream() throws Exception {
    final String delimiter = "\r\n";
    return new InputOf(
        new Joined(
            delimiter,
            "GET / HTTP/1.1",
            new FormattedText(
                "Host: %s",
                this.host
            ).asString(),
            "Connection: close",
            delimiter
        )
    ).stream();
}
 

@Test
public void takesBodyOutOfHttpResponse() {
    MatcherAssert.assertThat(
        new TextOf(
            new HtBody(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        "Hello, dude!",
                        "How are you?"
                    )
                )
            )
        ),
        new TextHasString("Hello, dude!\r\nHow are you?")
    );
}
 

@Test
public void takesHeadersOutOfHttpResponse() throws IOException {
    MatcherAssert.assertThat(
        new HtHeaders(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        "Hello, dude!",
                        "How are you?"
                    )
                )
            )
        ),
        new IsMapContaining<>(
            new IsEqual<>("content-type"),
            new IsEqual<>(new ListOf<>("text/plain"))
        )
    );
}
 

@Test
public void takesHeadOutOfHttpResponse() {
    new Assertion<>(
        "Header does not have 'text/plain'",
        new TextOf(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        "Hello, dude!"
                    )
                )
            )
        ),
        new EndsWith("text/plain")
    ).affirm();
}
 

@Override
public Input send(final Input input) throws Exception {
    final Socket socket = this.supplier.value();
    final InputStream source = input.stream();
    final InputStream ins = socket.getInputStream();
    final OutputStream ous = socket.getOutputStream();
    final byte[] buf = new byte[HtWire.LENGTH];
    while (true) {
        final int len = source.read(buf);
        if (len < 0) {
            break;
        }
        ous.write(buf, 0, len);
    }
    return new InputOf(ins);
}
 

/**
 * Ctor.
 *
 * @param url Url to GET.
 */
public Get(final URI url) {
    super(new InputOf(
        new Joined(
            new TextOf("\r\n"),
            new FormattedText(
                "GET %s HTTP/1.1",
                url.getPath()
            ),
            new FormattedText(
                "Host: %s",
                url.getHost()
            )
        )
    ));
}
 

/**
 * Ctor.
 * @param wre The wire
 * @param mtimeout The timeout for the connection usage in milliseconds
 * @param rmax The maximum quantity of the requests within the connection
 *  timeout
 * @param req The request
 * @checkstyle ParameterNumberCheck (2 lines)
 */
public HtKeepAliveResponse(
    final Wire wre, final long mtimeout, final int rmax, final String req
) {
    super(
        new HtResponse(
            wre,
            new InputOf(
                new FormattedText(
                    HtKeepAliveResponse.TEMPLATE,
                    req,
                    mtimeout,
                    rmax
                )
            )
        )
    );
}
 

@Test
public void emptyHeadOfHttpResponse()  {
    new Assertion<>(
        "Text does not have an empty string",
        new TextOf(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "",
                        "",
                        "Body"
                    )
                )
            )
        ),
        new TextHasString("")
    ).affirm();
}
 

@Test
public void largeText() throws Exception {
    //@checkstyle MagicNumberCheck (1 lines)
    final byte[] bytes = new byte[18000];
    new Random().nextBytes(bytes);
    new Assertion<>(
        "Header does not have text/plain header",
        new TextOf(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "",
                        new TextOf(new BytesOf(bytes)).asString()
                    )
                )
            )
        ),
        new EndsWith("text/plain")
    ).affirm();
}
 

@Test
public void takesCookiesOfHttpResponse() {
    MatcherAssert.assertThat(
        new HtCookies(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "Set-Cookie: path=/; domain=.google.com",
                        "",
                        "Hello, dude!",
                        "How are you?"
                    )
                )
            )
        ),
        new IsMapContaining<>(
            new IsEqual<>("domain"),
            new IsEqual<>(new ListOf<>(".google.com"))
        )
    );
}
 

/**
 * Main can print a simple text.
 * @throws Exception If some problem inside
 */
public void testSimpleCompilation() throws Exception {
    final CompileMojo mojo = new CompileMojo();
    this.temp.create();
    final File src = this.temp.newFolder();
    this.setVariableValueToObject(mojo, "sourceDirectory", src);
    new LengthOf(
        new TeeInput(
            new InputOf(
                "type Pixel:\n  Pixel moveTo(Integer x, Integer y)"
            ),
            new OutputTo(new File(src, "main.eo"))
        )
    ).value();
    final File target = this.temp.newFolder();
    this.setVariableValueToObject(mojo, "targetDirectory", target);
    this.setVariableValueToObject(mojo, "project", new MavenProjectStub());
    mojo.execute();
    MatcherAssert.assertThat(
        new File(target, "Pixel.java").exists(),
        Matchers.is(true)
    );
}
 

@Test(expected = IllegalArgumentException.class)
public void incorrectHttpResponseCookie() {
    MatcherAssert.assertThat(
        new HtCookies(
            new HtHead(
                new InputOf(
                    new Joined(
                        "\r\n",
                        "HTTP/1.1 200 OK",
                        "Content-type: text/plain",
                        "Set-Cookie: path=/; 123; domain=.google.com",
                        "",
                        "Hello, dude!",
                        "How are you?"
                    )
                )
            )
        ),
        new IsMapContaining<>(
            new IsEqual<>("domain"),
            new IsEqual<>(".google.com")
        )
    );
}
 

@Test
public void redirectsRequestAutomatically() throws Exception {
    new FtRemote(new TkText("redirected ok")).exec(
        home -> MatcherAssert.assertThat(
            "Does not redirects automatically",
            new TextOf(
                new HtAutoRedirect(
                    new InputOf(
                        new Joined(
                            new TextOf("\r\n"),
                            new TextOf("HTTP/1.1 301"),
                            new FormattedText(
                                "Location: %s", home
                            )
                        )
                    )
                )
            ),
            new TextHasString("HTTP/1.1 200 ")
        )
    );
}
 

/**
 * Compile one EO file.
 * @param file EO file
 */
private void compile(final Path file) {
    try {
        new Program(
            new InputOf(file),
            this.targetDirectory.toPath()
        ).compile();
    } catch (final IOException ex) {
        throw new IllegalStateException(
            new UncheckedText(
                new FormattedText(
                    "Can't compile %s into %s",
                    file, this.targetDirectory
                )
            ).asString(),
            ex
        );
    }
    Logger.info(this, "%s compiled to %s", file, this.targetDirectory);
}
 

@Override
public ServletOutputStream getOutputStream() throws IOException {
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    new LengthOf(
        new TeeInput(
            new InputOf(this.response.get().body()),
            new OutputTo(baos)
        )
    ).intValue();
    return new ServletOutputStreamTo(baos);
}
 

/**
 * Creates Java code that really works.
 * @throws Exception If some problem inside
 */
@Test
public void compilesExecutableJava() throws Exception {
    final ByteArrayOutputStream baos = new ByteArrayOutputStream();
    final Program program = new Program(
        new InputOf(
            new JoinedText(
                "\n",
                "object car as Serializable:",
                "  Integer @vin",
                "  String name():",
                "    \"Mercedes-Benz\""
            ).asString()
        ),
        s -> new OutputTo(baos)
    );
    program.compile();
    try (final GroovyClassLoader loader = new GroovyClassLoader()) {
        final Class<?> type = loader.parseClass(
            new GroovyCodeSource(
                new TextOf(baos.toByteArray()).asString(),
                "car", GroovyShell.DEFAULT_CODE_BASE
            )
        );
        MatcherAssert.assertThat(
            type.getMethod("name").invoke(
                type.getConstructor(Integer.class).newInstance(0)
            ),
            Matchers.equalTo("Mercedes-Benz")
        );
    }
}
 

/**
 * Program can parse a type with multiple methods.
 * @throws Exception If some problem inside
 */
@Test(expected = CompileException.class)
public void failsOnBrokenSyntax() throws Exception {
    final Program program = new Program(
        new InputOf("this code is definitely wrong"),
        Files.createTempDirectory("")
    );
    program.compile();
}
 

/**
 * Body.Stream can provide the expected input.
 * @throws Exception If there is some problem inside.
 */
@Test
public void returnsCorrectInputWithStream() throws Exception {
    final byte[] bytes =
        new BytesOf("Stream returnsCorrectInput!").asBytes();
    MatcherAssert.assertThat(
        "Body content of Body.Stream doesn't provide the correct bytes",
        new BytesOf(
            new Body.Stream(new InputOf(bytes).stream())
        ).asBytes(),
        new IsEqual<>(bytes)
    );
}