相关疑难解决方法(0)

我有一些代码使用try资源和jacoco它只有一半覆盖.所有的源代码行都是绿色的,但我得到一个黄色的小符号告诉我8个分支中只有4个被覆盖.

我无法弄清楚所有分支是什么,以及如何编写涵盖它们的代码.扔三个可能的地方PipelineException.这些createStageList(),processItem()以及隐含的close()

1. 没有抛出任何例外,
2. 抛出异常 createStageList()
3. 抛出异常 processItem()
4. 抛出异常 close()
5. 从processItem()和抛出异常close()

我想不出任何其他情况,但我仍然只有8个中有4个被覆盖.

有人可以向我解释为什么它是8中的4,并且无论如何都可以击中所有8个分支？我不熟悉decyrpting /阅读/解释字节码,但也许你是...... :)我已经看过https://github.com/jacoco/jacoco/issues/82,但它既不是也不是问题它非常引用帮助(除了注意这是由于编译器生成的块)

嗯,就在我写完这篇文章的时候,我想到了上面提到的那些案例可能没有被测试过......如果我做对了,我会发一个答案.我确信这个问题和答案在任何情况下都会对某人有所帮助.

编辑:没有,我没有找到它.抛出RuntimeExceptions(不由catch块处理)不包括任何更多分支

鉴于此计划:

class Test {
    public static void main(String[] args) {
        try {
            throw new NullPointerException();
        } catch (NullPointerException npe) {
            System.out.println("In catch");
        } finally {
            System.out.println("In finally");
        }
    }
}

Sun javac(v 1.6.0_24)生成以下字节码:

public static void main(java.lang.String[]);

        // Instantiate / throw NPE
   0:   new     #2;         // class NullPointerException
   3:   dup
   4:   invokespecial   #3; // Method NullPointerException."<init>":()V
   7:   athrow

        // Start of catch clause
   8:   astore_1
   9:   getstatic       #4; // Field System.out
   12:  ldc     #5;         // "In catch"
   14:  invokevirtual …

我有一些junit测试可以创建一些应该关闭的资源.

实现此逻辑的一种方法是使用@Before和@After方法.

我所做的是将创建封装在一些实用程序类中以供重用.例如:

class UserCreatorTestUtil implements AutoClosable {
  User create() {...}
  void close() {...}
}

关键是对象要关闭自己,而不是需要记住关闭它@After.

用法应该是:

@Test
void test() {
  try (UserCreatorTestUtil userCreatorTestUtil = new UserCreatorTestUtil()) {
    User user = userCreatorTestUtil.create();
    // Do some stuff regarding the user's phone
    Assert.assertEquals("123456789", user.getPhone());
  }
}

问题是junit的assert关键字抛出Error- 而不是Exception.

try-with-resource会"捕获" Error并调用close方法吗？

*在try-with-resources文档中找不到答案.

考虑以下一组表达式:

class T {{
/*1*/   super.toString();      // direct
/*2*/   T.super.toString();    // synthetic
        Supplier<?> s;
/*3*/   s = super::toString;   // synthetic
/*4*/   s = T.super::toString; // synthetic
}}

这给出了以下结果:

class T {
    T();
     0  aload_0 [this]
     1  invokespecial java.lang.Object() [8]
     4  aload_0 [this]
     5  invokespecial java.lang.Object.toString() : java.lang.String [10]
     8  pop           // ^-- direct
     9  aload_0 [this]
    10  invokestatic T.access$0(T) : java.lang.String [14]
    13  pop           // ^-- synthetic
    14  aload_0 [this]
    15  invokedynamic 0 get(T) : java.util.function.Supplier [21]
    20  astore_1 [s] …

我正在开发一个业余的JVM实现,我正在努力确保我对规范中的所有操作码都有测试覆盖率.我已经得到它倒在过去的几年,但nop和swap已经躲避我.例如,这是一个可能使用的简单函数swap:

static int do_swap() {
  int a = 56;
  int b = 32;
  return b%a;
}

但是生成的字节码javac 1.6避免了交换代替本地存储:

static int do_swap();
  Code:
   0:   bipush  56
   2:   istore_0
   3:   bipush  32
   5:   istore_1
   6:   iload_1
   7:   iload_0
   8:   irem
   9:   ireturn

有任何想法吗？

Java字节码指令集提供了多种形式的dup指令。我无法理解这些说明和swap说明如何有用。编译时，哪些 Java 代码会使用这些指令生成字节码？

我们目前有在 Java 8 中编译的代码，但我们正在 Java 11 VM 上运行它。现在我们也在尝试将我们的代码移动到 Java 11 编译时。想知道 Java 8 中的编译代码与 Java 11 中的编译代码在性能方面是否有任何好处，因为两个编译器都会生成不同的类文件（字节码）？一个在效率方面与另一个有何不同？