测试大类

生命周期

显示

生命周期

很多注解都是元注解，可以自定义组合注解

@Nested 测试让 书写者更方便表达多组测试类的关系。

事实上外部类比内部类更早执行，让你有能力独立跑所有测试类。你可以让内部类运行，而不运行外部类，因为外部类一直会执行。

这周六为了寄东西，去邮政。因为上海虽然解封，但实际上没完全解封，快递除了京东和顺丰，还都不行。顺丰有点贵，我们转卖一个年会中颈部按摩，电流刺激的，感觉没啥用，就挂了68还包邮，那就最便宜的吧。因为疫情，邮政就开了一个窗口，不光寄东西，还有好多老人来缴费，水电费，话费，虽然其他手机途径也可以，但老人们不会，只知道来着，大下午就排队，从2点排到4点，之前去问就说要身份证，其他没说。
排队很热，我都腰酸背痛了，别说老年人了。等我了，突然跟我说，你这个不能外面包泡沫纸，是电器，大箱子一起放，80%会被压坏。当时感觉是日了狗了，早你不说，排了2个小时，跟我说这个？沉没成本很高，要是你早说，我就顺丰寄，贵点就贵点，起码还能卖钱。你这个80%压坏，我既赔了东西， 还赔了邮寄费，还浪费了我2个小时，这我完全是亏本的。
排队的时候，我就在想，排队前，最好完全知道入口校验规则，符合规则再排队，起码目标不能错，经过不确定时间的执行，最后到门口校验是否达到入口目标。如果一开始，连目标规则都不知道，那完全也不可能正好碰巧符合标准，正好能进入。
这个跟我们人生很像，平时我们对未来，只有一个模糊的印象，随着时间走，恰巧到了某个时间点，有某个入口可以进，但你从来不知道入口检查标准，慌乱拼凑，那必然校验不通过，然后你就是好像，人生过了很久也一事无成。因为你从一开始就没有目标，那到了各个人生的不同入口检验必然过不去。

第二个思考，就是任何思考如果不能改变行为或习惯，那就完全没什么用。之前居家办公是一个实例，大环境时间变多了，通勤时间变少了，但我习惯没变，所以只是把之前工作的时间变长，其他什么都没变。
所以我进一步想，既然每个思考都要改变行动，那不就是要总结自己的原则，按照原则去办事，先思考各种情况，总结成办事原则，减少不必要的思考，行动按原则判断，思考改变原则，原则影响行为习惯，这样思考才能改成一个人。

题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/squares-of-a-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

说明

思路1
先遍历平方一次，找到非负数的位置，然后从非负数的位置冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Solution {
    public int[] sortedSquares(int[] nums) {
        int begin = 0;
        for(int i =0 ; i< nums.length; i++){
            nums[i] = nums[i] * nums[i];
            if(nums[i]>=0){
                begin = i;
            }
        }
        
        while(begin>=0){
            for(int j = begin ; j < nums.length-1 ; j++){
                if(nums[j] > nums[j+1]){
                    int temp = nums[j];
                    nums[j] = nums[j+1];
                    nums[j+1] = temp;
                }else{
                    break;
                }
            }
            begin--;
        }
        return nums;
    }
}

思路2
双指针法，头尾2个指针，取大放入到新数组里

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Solution {
    public int[] sortedSquares(int[] nums) {
        int i = 0;
        int j = nums.length-1;
        int k = nums.length-1;
        int[] result = new int[nums.length];
        while(i<=j){
            if(nums[i]*nums[i] <= nums[j]*nums[j]){
                result[k--] =  nums[j]*nums[j];
                j--;
            }else{
                result[k--] = nums[i]*nums[i];
                i++;
            }
        }
        return result;
    }
}

Junit5的注解有个比较有意思的特点就是都是meta-annotation 元注解，感觉比较有趣。
但经过搜索，没看到直接的分析是如何实现的，看到一篇Dzone的分析，但貌似跟现有junit实现不太一致，但也是一种思路。
注解本身是不会影响运行时的程序，需要在处理类里面去根据注解信息判断，Dzone的分析大致过程应该是对的，就是具体实现有各种情况。
我看到一个junit5的注解读取工具类，里面就一个读取元注解的，仔细看了一下，就是递归遍历，当前注解以及直接下级注解，然后再遍历递归，就能找到要找的元注解。
其他我还没完全弄懂，只是一个自认为可以的思路，junit加载的机制还没弄清楚，还需要继续深入理解。

题目

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路1
将跟值一样的，跟最后一位进行交换，这样就能保证原地查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Solution {
    public int removeElement(int[] nums, int val) {
        int last = nums.length -1;
        int begin = 0;
        while(begin <= last){
            if(nums[begin] == val){
                int temp = nums[begin];
                nums[begin] = nums[last];
                nums[last] = temp;
                last--;
            }else{
                begin++;
            }
        }
        return last+1;
    }
}

思路2
快慢指针法，快指针循环遍历，慢指针停留在需要替换的问题，当快指针走的时候，如果值不等val，就替换慢指针，直到循环结束

1
2
3
4
5
6
7
8
9
10
11

class Solution {
    public int removeElement(int[] nums, int val) {
        int slow = 0;
        for(int fast = 0 ; fast < nums.length ; fast++){
            if(nums[fast] != val){
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
}

居家办公3个月，发现一个其他的现象，通勤时间每天节约2个小时，但每天工作的时间反而增多了。
原来每天6点45闹钟，7点20出门，到公司8点20左右，稍微晚点会迟到。
现在每天7点45闹钟，洗漱，打开电脑发上班打卡邮件，8点半左右吃早饭。
时间看起是多了一个小时睡觉。

原来晚上早的话7点多下班，地铁1个小时，到家也要8点左右。晚一点就8点半打车回家，到家9点左右。
现在6点左右开完夕会，开始做饭吃饭，饭后休息到7，8点，继续干活。9点多打卡下班，晚到10，11点。
每天路上的时间少了，但其他的事情却没干，还是干了工作，工作有的时候效率比较低，沟通不顺畅。

所以只是客观条件变化，不会改变你个人的实际情况，要改变你的习惯，才能真实改变你的现状。从自己的习惯，改变做起，才能改变你的现状。不能把自己的改变依托于环境，环境会改变人，是改变了人的习惯。但环境不一定能改变你的习惯，所以要主动改变习惯。

为了每个test方法独立的执行和避免不可变单元测试非预期的副作用，junit在每个方法执行前创建一个测试实例。
如果你想jupiter执行所有方法在相同的测试实例，在你的测试类上添加注解 @TestInstance(Lifecycle.PER_CLASS)。如果使用这种模式，每个测试类将生成一个测试实例。因此如果你的测试方法依赖实例状态，你可能需要在@BeforeEach @AfterEach重置状态。
“per-class“ 模式有一些额外的好处对比默认的“per-method”模式。尤其，“per-class”通过接口模式方法可以使用非静态方法实现@BeforeAll @AfterAll。“per-class在@Nested测试类里也可以实现@BeforeAll 和@AfterAll

@Timeouts 注解允许 定义 test，test factory，test template或lifeCycle method 在给定的时间内没执行晚，测试用例就失败。时间长度默认是秒但可以配置。
与assertTimeoutPreemptively()相反，注解方法的执行在主线程。如果执行超时，主线程会被其他线程中断。这样做是为了保证诸如spring利用对当前线程敏感。例如threadlocal事务管理。
也可以应用在类上的所有方法或者是@Nested方法，在类上定义@Timeout注解。主要注意@Timeout定义在类上不能应用在lifecycle method
定义@Timeout在@TestFactory 方法上检查工厂方法是否在特定时间内返回，但是不能校验在每次独立的Dynamic Test
的执行时间。请使用assertTimeout() 或assertTimeoutPreemptively()。
如果@Timeout在@TestTemplate上，例如@RepeatedTest，@ParameterizedTest每次调用都会校验时间。
不同分类的测试方法，都有默认配置，可以自定义修改。

如果需要更多控制异步执行，可考虑Awaitility库。
为了不影响debug，可以全局关闭timeout

想想最近做的最多的事情，就是带外包。觉得自己要有思考的做这些事情，就总结一下思考。
首先要在关键的事情上问几个好问题。不一定都能解答，但一定要看到关键的问题。你不一定也不应该解决所有问题，但一定要看到所有问题。
比如我在之前工作新空降的领导，首先做的就是梳理流程，工作的主要流程，都是怎么做的，都是谁在做。遇到问题如何处理。
要转变一些看法，你没法做所有事情，要克服自己做所有事情的冲突，你会有一种完美冲动要做所有事情，但事实上，这只会增加你的工作内容，又跟下级争抢成长空间，你要带头突破一些你不会的，同时也要教会你下级该怎么做，怎么自我突破，自我学习，不然你会很累，下级也觉得自己没有成长。
把大家凝聚在一起的是收益，可能是物质收益，比如金钱，可能是能力上的收益比如成长，只有大家在这些方面长期看都是正收益的，才能长时间在一起，不然可能短期利益让大家在一起，但长期会变。
我们被雇佣，最大的目标应该是公司的目标，然后是上级的目标，再然后是自己的目标，再然后是下级的目标。大家目标不同，但要争取自己最大的利益，哪些目标是对上级的，对公司，这些对自己有什么收益，如何达成自己的目标。如果达成下级的目标，对这些进行调和。

将流程落到具体可执行的条款，同时进行检查，用不同视角，审视是否合理。
至于具体如何实施，可以慢慢摸索，要有一定的适应度，对不合理的理解，以及容忍，等你可以有指导方案，再逐渐完善。