测试与调试

亦凉 2022-12-25 13:56 135阅读 0赞

## 1.测试 ##

### 1.1 测试可见 Lambda 函数的行为 ###

可以借助某个字段访问Lambda函数，这种情况，你可以利用这些字段，通过它们对封装在Lambda函数内的逻辑进行测试。

//比如，我们假设你在Point类中添加了静态字段compareByXAndThenY
    public class Point{  
     public final static Comparator<Point> compareByXAndThenY = 
     	comparing(Point::getX).thenComparing(Point::getY); 
     	… 
    }
    
    //Lambda表达式会生成函数接口的一个实例compareByXAndThenY。由此，你可以测试该实例的行为。
    
    ```java
    @Test 
    public void testComparingTwoPoints() throws Exception {  
       Point p1 = new Point(10, 15); 
       Point p2 = new Point(10, 20); 
       int result = Point.compareByXAndThenY.compare(p1 , p2); 
       assertEquals(-1, result); 
    }

### 1.2. 测试使用 Lambda 的方法的行为 ###

Lambda的初衷是将一部分逻辑封装起来给另一个方法使用，所以测试一般是针对方法，而非Lambda自身。

public static List<Point> moveAllPointsRightBy(List<Point> points, int x){  
     return points.stream() 
     .map(p -> new Point(p.getX() + x, p.getY())) 
     .collect(toList()); 
    }
    
    //我们没必要对Lambda表达式p -> new Point(p.getX() + x,p.getY())进行测试
    //只需要对moveAllPointsRightBy进行测试

### 1.3. 将复杂的 Lambda 表达式分到不同的方法 ###

可能你会碰到非常复杂的Lambda表达式，包含大量的业务逻辑，比如需要处理复杂情况的定价算法。你无法在测试程序中引用Lambda表达式，这种情况该如何处理呢？一种策略是将Lambda表达式转换为方法引用（这时你往往需要声明一个新的常规方法）

### 1.4. 高阶函数的测试 ###

高阶函数：接受函数作为参数的方法或者返回一个函数的方法。

//如果一个方法接受Lambda表达式作为参数
    //你可以采用的一个方案是使用不同的Lambda表达式对它进行测试
    @Test 
    public void testFilter() throws Exception{  
       List<Integer> numbers = Arrays.asList(1, 2, 3, 4); 
       List<Integer> even = filter(numbers, i -> i % 2 == 0); 
       List<Integer> smallerThanThree = filter(numbers, i -> i < 3); 
       assertEquals(Arrays.asList(2, 4), even); 
       assertEquals(Arrays.asList(1, 2), smallerThanThree); 
    }
    
    //如果被测试方法的返回值是另一个方法，该如何处理呢？
    --->把它当成一个函数接口，对它的功能进行测试

## 2.调试 ##

### 2.1 Lambda表达式的栈跟踪可能非常难理解 ###

import java.util.*; 
    public class Debugging{  
        public static void main(String[] args) {  
            List<Point> points = Arrays.asList(new Point(12, 2), null); 
            points.stream().map(p -> p.getX()).forEach(System.out::println); 
        } 
    } 
    //运行这段代码会产生下面的栈跟踪：
    Exception in thread "main" java.lang.NullPointerException 
     at Debugging.lambda$main$0(Debugging.java:6) //这行中的$0是什么意思？
     at Debugging$$Lambda$5/284720968.apply(Unknown Source) 
     at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline 
     .java:193) 
     at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators 
     .java:948) 
    …
    
    //即使你使用了方法引用，还是有可能出现栈无法显示你使用的方法名的情况。
    //将之前的Lambda表达式p-> p.getX()替换为方法引用reference Point::getX也会产生难于分析的栈跟踪：
    points.stream().map(Point::getX).forEach(System.out::println); 
    Exception in thread "main" java.lang.NullPointerException 
     at Debugging$$Lambda$5/284720968.apply(Unknown Source) //这一行表示什么呢？
     at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline 
     .java:193) 
    …
    
    //注意，如果方法引用指向的是同一个类中声明的方法，那么它的名称是可以在栈跟踪中显示的。
    import java.util.*; 
    public class Debugging{  
        public static void main(String[] args) {  
             List<Integer> numbers = Arrays.asList(1, 2, 3); 
             numbers.stream().map(Debugging::divideByZero).forEach(System.out::println); 
         } 
     
         public static int divideByZero(int n){  
              return n / 0; 
         } 
    } 
    //方法divideByZero在栈跟踪中就正确地显示了：
    Exception in thread "main" java.lang.ArithmeticException: / by zero 
     at Debugging.divideByZero(Debugging.java:10) 
     at Debugging$$Lambda$1/999966131.apply(Unknown Source) 
     at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline 
     .java:193) 
    …

### 2.2 使用日志调试 ###

使用peek输出了Stream流水线操作之前和操作之后的中间值。

List<Integer> numbers = Arrays.asList(2, 3, 4, 5); 
    numbers.stream() 
    	 .map(x -> x + 17) 
    	 .filter(x -> x % 2 == 0) 
    	 .limit(3) 
    	 .forEach(System.out::println); 
    
    ===>
    
    List<Integer> result = 
     numbers.stream() 
    	 .peek(x -> System.out.println("from stream: " + x))
    	 .map(x -> x + 17) 
    	 .peek(x -> System.out.println("after map: " + x)) 
    	 .filter(x -> x % 2 == 0) 
    	 .peek(x -> System.out.println("after filter: " + x))
    	 .limit(3) 
    	 .peek(x -> System.out.println("after limit: " + x))
    	 .collect(toList());