Jin Kwon's questions

Digamos que eu tenha uma superclasse abstrata e uma classe de teste abstrata para testar subclasses.

abstract class Superclass {
}

@RequiredArgsConstructor
abstract class SuperclassTest<T extends Superclass> {

    SuperclassTest(Class<T> typeClass) {
        super();
        this.typeClass = typeClass;
    }

    @Nested
    class ToStringTest {

         @Test
         void _NotBlank_NewInstance() {
             String string = newInstance().toString();
             assertThat(string).isNotBlank();
         }
    }

    final Class<T> typeClass;
}

Agora, como posso substituir a classe/método de teste aninhado para desabilitar ou modificar?

class SomeTest extends SuperclassTest<Some> {

    SomeTest() {
        super(Some.class)
    }

    // How can I disable or change ToStringTest#_NotBlank_NewInstance?
}

De acordo com a documentação , StandardOpenOption.APPENDparece que requer o StandardOpenOption.WRITE.

Se o arquivo for aberto para WRITEacesso, os bytes serão gravados no final do arquivo e não no início.

Se o arquivo for aberto para acesso de gravação por outros programas, então ele será específico do sistema de arquivos se a gravação no final do arquivo for atômica.

É verdade?

Testei StandardOpenOption.APPENDapenas com e funciona.

@Test
void __(@TempDir final Path dir) throws Exception {
    final var path = Files.createTempFile(dir, null, null);
    final var b = ByteBuffer.allocate(12);
    try (var channel = FileChannel.open(path, StandardOpenOption.APPEND)) {
        while (b.hasRemaining()) {
            channel.write(b);
        }
        channel.force(true);
    }
    Assertions.assertEquals(Files.size(path), b.capacity());
}

O que o comentário significa?

Se o arquivo for aberto para WRITEacesso, os bytes serão gravados no final do arquivo e não no início.

Digamos que precisamos verificar o seguinte método.

    /**
     * Prints {@code hello, world}, to the {@link System#out}, followed by a system dependent line separator.
     *
     * @param args command line arguments.
     */
    public static void main(String... args) {
        System.out.printf("hello, world%n"); // %n !!!!!!
    }

Agora podemos verificar se o método imprime o hello, world.

    /**
     * Verifies that the {@link HelloWorld#main(String...)} method prints {@code hello, world}, to the
     * {@link System#out}, followed by a system-dependent line separator.
     *
     * @author Jin Kwon <onacit_at_gmail.com>
     * @see System#lineSeparator()
     */
    @DisplayName("main(args) prints 'hello, world' followed by a system-dependent line separator")
    @Test
    public void main_PrintHelloWorld_() {
        final var out = System.out;
        try {
            // --------------------------------------------------------------------------------------------------- given
            final var buffer = new ByteArrayOutputStream();
            System.setOut(new PrintStream(buffer));
            // ---------------------------------------------------------------------------------------------------- when
            HelloWorld.main();
            // ---------------------------------------------------------------------------------------------------- then
            final var actual = buffer.toByteArray();
            final var expected = ("hello, world" + System.lineSeparator()).getBytes(StandardCharsets.US_ASCII);
            Assertions.assertArrayEquals(actual, expected);
        } finally {
            System.setOut(out);
        }
    }

A parte questionável é o .getBytes(StandardCharsets.US_ASCII).

Não acho errado presumir que o separador de linha dependente do sistema codifica com US_ASCII.

O Charset#defaultCharset() é adequado para o %n?

Tenho um controlador que define os seguintes métodos.

    Mono<EntityModel<Some>> readSome(...) {
        // works, simply.
    }

    Flux<EntityModel<Other>> readOther(...) {
        // works, simply.
    }

E, dentro da minha classe de teste, defini os seguintes métodos que funcionam.

    // WORKS!
    static List<EntityModel<Some>> readSome(...) {
        client...
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(new TypeReferences.EntityModelType<Some>() {
                })
                .returnResult()
                .getResponseBody();
    }

    // WORKS!
    static List<EntityModel<Other>> readOther(...) {
        client...
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(new TypeReferences.EntityModelType<Other>() {
                })
                .returnResult()
                .getResponseBody()
    }

E eu naturalmente defini o seguinte método para todos os tipos.

Como você pode ver, é apenas um método genérico para todos os tipos.

    private static <T> List<EntityModel<T>> readList(final WebTestClient client,
                                                     final Function<UriBuilder, URI> uriFunction,
                                                     @Nullable final String accept) {
        final var responseBody = client
                .get()
                .uri(uriFunction)
                .headers(h -> {
                    Optional.ofNullable(accept)
                            .map(MediaType::valueOf)
                            .map(List::of)
                            .ifPresent(h::setAccept);
                })
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(new TypeReferences.EntityModelType<T>() { // NOT <T>, BUT Map
                })
                .returnResult()
                .getResponseBody();
        return Objects.requireNonNull(responseBody, "responseBody is null");
    }

Agora, quando altero o método readSome| readOthercom o readListmétodo , vejo um comportamento estranho.

O Jackson não analisa mais o conteúdo no , mas em um LinkedHashMap.

Como posso especificar Class<T>com o TypeReferences.EntityModelType<T>?

Eu tenho métodos utilitários parecidos com este.

    public static WebClient.ResponseSpec retrieve(final String baseUrl, final Duration responseTimeout) {
        // ...
    }

    public static <T> Flux<T> retrieveBodyToFlux(final String baseUrl, final Duration responseTimeout,
                                                 final Class<T> elementClass) {
        return retrieve(baseUrl, responseTimeout)
                .bodyToFlux(elementClass);
    }

    public static Mono<Void> download(final String baseUrl, final Duration responseTimeout,
                                      final Path destination, final OpenOption... openOptions) {
        return DataBufferUtils.write(
                retrieveBodyToFlux(baseUrl, responseTimeout, DataBuffer.class),
                destination,
                openOptions
        );
    }

Agora quero adicionar outro método para o cliente consumir um arquivo temporário.

    // Let me download the file, and you can just cononsume the file!
    public static Mono<Void> download(final String baseUrl, final Duration responseTimeout,
                                      final Consumer<? super Path> consumer) {

        // Create a temp file
        // download the URL to the file
        // accept the file to the consumer; possibly blocking IO operations
        // don't forget to delete the file!
    }

Como posso fazer o trabalho sem nenhum aviso de bloqueio de chamada?

Eu tentei (e parece funcionar), mas estou me perguntando o que estou fazendo. É ideal? Eu tenho outras maneiras?

        return Mono.usingWhen(
                        Mono.fromCallable(() -> Files.createTempFile(null, null)).subscribeOn(Schedulers.boundedElastic()),
                        p -> download(baseUrl, responseTimeout, p, StandardOpenOption.WRITE)
                                .then(Mono.just(p))
                                .doOnNext(consumer).subscribeOn(Schedulers.boundedElastic()),
                        p -> Mono.fromCallable(() -> {
                            Files.delete(p);
                            return null;
                        }).publishOn(Schedulers.boundedElastic()).then()
                )
                .then();

Acabei de descobrir que Instant#ofEpochSecond(epochSecond)tem valores mínimos/máximos.

Aí vem os códigos-fonte.

// Instant.java
    /**
     * The minimum supported epoch second.
     */
    private static final long MIN_SECOND = -31557014167219200L;
    /**
     * The maximum supported epoch second.
     */
    private static final long MAX_SECOND = 31556889864403199L; // << I WANT THIS VALUE!

Como posso obter o MAX_SECONDprogramaticamente?

Eu tentei descobrir com Range,

        final var range = ChronoField.INSTANT_SECONDS.range();
        log.debug("        minimum: {}", range.getMinimum());
        log.debug(" largestMinimum: {}", range.getLargestMinimum());
        log.debug("        maximum: {}", range.getMaximum());
        log.debug("smallestMaximum: {}", range.getSmallestMaximum());

e não tem sorte.

03:53:36.120 [                main] DEBUG -         minimum: -9223372036854775808
03:53:36.122 [                main] DEBUG -  largestMinimum: -9223372036854775808
03:53:36.122 [                main] DEBUG -         maximum: 9223372036854775807
03:53:36.122 [                main] DEBUG - smallestMaximum: 9223372036854775807

Eu crio uma matriz de bytes.

array = bytearray(random.randint(1, 8192))

# Now, how can I randomize array's elements?

Agora, como posso randomizar cada elemento do array?

Assim como,

// with Java
var array = new byte[ThreadLocalRandom.current().nextInt(1, 8192)];
ThreadLocalRandom.current().nextBytes(array);