Jin Kwon's questions

假设我有一个抽象超类和一个用于测试子类的抽象测试类。

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;
}

现在，我如何覆盖嵌套的测试类/方法来禁用或修改？

class SomeTest extends SuperclassTest<Some> {

    SomeTest() {
        super(Some.class)
    }

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

根据文档，StandardOpenOption.APPEND似乎它需要StandardOpenOption.WRITE。

如果打开文件进行WRITE访问，那么字节将被写入文件末尾而不是开头。

如果该文件由其他程序打开以进行写访问，并且写入文件末尾是原子的，则它是特定于文件系统的。

这是真的吗？

我StandardOpenOption.APPEND仅测试了它，并且它有效。

@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());
}

这个评论是什么意思？

如果打开文件进行WRITE访问，那么字节将被写入文件末尾而不是开头。

假设我们需要验证以下方法。

    /**
     * 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 !!!!!!
    }

现在我们可以验证该方法是否打印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);
        }
    }

有疑问的部分是.getBytes(StandardCharsets.US_ASCII)。

我认为，假设系统相关的行分隔符用 进行编码并没有错US_ASCII。

Charset #defaultCharset()是否适合%n？

我有一个控制器定义了以下方法。

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

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

并且，在我的测试类中，我定义了以下有效的方法。

    // 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()
    }

我自然而然地为所有类型定义了以下方法。

如您所见，它只是所有类型的通用方法。

    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");
    }

现在，当我用该方法改变readSome|方法时，我看到了一种奇怪的行为。readOtherreadList

Jackson 不再将内容解析为，而是解析为LinkedHashMap。

我该如何使用Class<T>来指定TypeReferences.EntityModelType<T>？

我有类似这样的实用方法。

    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
        );
    }

现在我想添加另一种方法让客户端使用临时文件。

    // 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!
    }

我怎样才能在没有任何阻塞呼叫警告的情况下完成这项工作？

我试过了（似乎有效），但我不知道我做了什么。这是最佳选择吗？我还有其他方法吗？

        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();

我刚刚发现 具有Instant#ofEpochSecond(epochSecond)最小值/最大值。

这里是源代码。

// 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!

我如何以MAX_SECOND编程方式获取？

我试图弄清楚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());

并且没有运气。

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

我创建了一个字节数组。

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

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

现在我怎样才能随机化 的每个元素array？

就像，

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