कोटलिन द्वारा उत्पन्न अनावश्यक अशक्त जांच को कैसे कवर किया जाए?

Question

निम्नलिखित न्यूनतम कोटलिन उदाहरण पर विचार करें:

fun <U> someWrapper(supplier: () -> U): () -> (U) {
    return { supplier() }
}

fun foo(taskExecutor: TaskExecutor): Int {
    val future = CompletableFuture.supplyAsync(someWrapper {
        42
    }, taskExecutor::execute)
    return future.join()
}

@Test
public void shouldFoo() {
    assertThat(foo(), is(42));
}

मेरे पास जैकोको में शाखा कवरेज नियम हैं, जो ऊपर दिए गए कोड के लिए विफल हैं, कहते हैं कि 2 में से 1 शाखा someWrapperकॉल की रेखा पर कवर नहीं है । दुर्भाग्य से, यह मेरे लिए सभी वर्गों को बाहर करने का विकल्प नहीं हैsomeWrapper है जिन्हें कहा जाता है।

विघटित जावा कोड को देखते हुए:

public final int foo(TaskExecutor taskExecutor) {
    Object var10000 = WrappersKt.someWrapper((Function0)null.INSTANCE);
    if (var10000 != null) {
        Object var2 = var10000;
        var10000 = new Foo$sam$java_util_function_Supplier$0((Function0)var2);
    }

    Supplier var3 = (Supplier)var10000;
    Function1 var4 = (Function1)(new Function1(this.taskExecutor) {
        // $FF: synthetic method
        // $FF: bridge method
        public Object invoke(Object var1) {
        this.invoke((Runnable)var1);
        return Unit.INSTANCE;
        }

        public final void invoke(Runnable p1) {
        ((TaskExecutor)this.receiver).execute(p1);
        }

        public final KDeclarationContainer getOwner() {
        return Reflection.getOrCreateKotlinClass(TaskExecutor.class);
        }

        public final String getName() {
        return "execute";
        }

        public final String getSignature() {
        return "execute(Ljava/lang/Runnable;)V";
        }
    });
    CompletableFuture future = CompletableFuture.supplyAsync(var3, (Executor)(new Foo$sam$java_util_concurrent_Executor$0(var4)));
    var10000 = future.join();
    Intrinsics.checkExpressionValueIsNotNull(var10000, "future.join()");
    return ((Number)var10000).intValue();
}

मुझे लगता है, समस्या यह है if (var10000 != null) शाखा है, जो आईडीई द्वारा अनावश्यक (हमेशा सच) होने के लिए भी चिह्नित है।

क्या किसी तरह कोड को समायोजित करना संभव है, जैसे कि सभी शाखाओं को कवर करना संभव है, जैसे। यह सुनिश्चित करने से कि संकलक उस अतिरिक्त अशक्त जाँच को उत्पन्न नहीं करता है? मैं दोनों का कोड बदल सकता हूं foo(..)औरsomeWrapper(..) जब तक मैं एक सजाया हुआ लैम्ब्डा आपूर्ति करने में सक्षम हूं।

मैं कोटलिन 1.3.50 और जैकोको 0.8.4 का उपयोग करता हूं।

संपादित करें।

एक स्पष्ट समाधान supplyAsync(someWrapper { ... })कुछ बर्तनों को कक्षा में निकालना और केवल उस वर्ग को बाहर करना है, अर्थात:

fun <U> supplyAsync(supplier: () -> U, executor: TaskExecutor): CompletableFuture<U> {
    return CompletableFuture.supplyAsync(someWrapper { supplier() }, executor::execute)
}

यह मेरे लिए काफी अच्छा होगा, हालांकि मैं अभी भी उत्सुक हूं कि कोटलिन द्वारा शाखा क्यों जोड़ी जाती है, जहां शाखा की आवश्यकता नहीं है।

Comments

मुझे Type inference failedआपका नमूना कोड संकलित करने का प्रयास करने पर मिलता है । बहुत अच्छा होगा यदि आप नमूना कोड प्रदान कर सकते हैं जो बॉक्स से बाहर काम करता है! उदाहरण के लिए, taskExecutorऔर controllerअज्ञात हैं।

— एनसेलिक

@Enselic ने विचलित करने वाली त्रुटियों को दूर करने के लिए छोटे संपादन जोड़े। मैं इसका पूर्ण विस्तार करने के लिए आगे नहीं जा रहा हूँ क्योंकि यह विचार प्राप्त करने के लिए पर्याप्त होना चाहिए।

— BKE

यह देखते हुए कि जैकोको ने कैसे कोटलिन का समर्थन करने के लिए उत्तरोत्तर बदलाव किया है (देखें github.com/jacoco/jacoco/releases और "कोटलिन कंपाइलर द्वारा जोड़ा गया"), मुझे लगता है कि यह सिर्फ एक और अंतर है जो बाद में तय किया जा रहा है। यदि आप अपने कवरेज के बारे में गंभीर महसूस करते हैं, तो मेरा सुझाव है कि किसी मुद्दे की रिपोर्टिंग करें।

— पायोत्र

Answer 1

यदि रिटर्न का मान someWrapperकेवल उदाहरण के रूप में उपयोग करने के लिए है Supplier, तो आप Supplierरिटर्न प्रकार के रूप में स्पष्ट रूप से उपयोग करके अनावश्यक अशक्त चेक को हटा सकते हैं ।

fun <U> someWrapper(supplier: () -> U): Supplier<U> {
    return Supplier { supplier() }
}