Skip to content

Commit 6dfaab5

Browse files
davidabramdavidabram
committed
cli: Add combine-intersect integration test with fixtures
Move inline tests from patch.rs to a dedicated tests.rs module and add an integration test proving combine_patches → intersect_patches produces the correct result when fed real incremental patch data. The test parses seven incremental patches (with corrected file paths), combines them, intersects with the post-commit patch, and asserts the intersection equals the post-commit patch itself.
1 parent 950904b commit 6dfaab5

13 files changed

Lines changed: 984 additions & 2599 deletions

‎cli/src/services/patch.rs‎

Lines changed: 2 additions & 2599 deletions
Large diffs are not rendered by default.

‎cli/src/services/patch/fixtures/average_age_reconstruction/golden.json‎

Lines changed: 544 additions & 0 deletions
Large diffs are not rendered by default.

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_01.patch‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
Index: hunks/unoptimized.ts
2+
===================================================================
3+
--- hunks/unoptimized.ts
4+
+++ hunks/unoptimized.ts
5+
@@ -0,0 +1,23 @@
6+
+type User = {
7+
+ age: number;
8+
+};
9+
+
10+
+export function getAverageAgeUnoptimized(users: User[]): number {
11+
+ if (users.length === 0) {
12+
+ return 0;
13+
+ }
14+
+
15+
+ let totalAge = 0;
16+
+
17+
+ for (let i = 0; i < users.length; i += 1) {
18+
+ let recalculatedTotal = 0;
19+
+
20+
+ for (let j = 0; j <= i; j += 1) {
21+
+ recalculatedTotal += users[j].age;
22+
+ }
23+
+
24+
+ totalAge = recalculatedTotal;
25+
+ }
26+
+
27+
+ return totalAge / users.length;
28+
+}

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_02.patch‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
Index: hunks/unoptimized.ts
2+
===================================================================
3+
--- hunks/unoptimized.ts
4+
+++ hunks/unoptimized.ts
5+
@@ -3,20 +3,23 @@
6+
};
7+
8+
export function getAverageAgeUnoptimized(users: User[]): number {
9+
if (users.length === 0) {
10+
+ // Return a safe default when there are no users.
11+
return 0;
12+
}
13+
14+
let totalAge = 0;
15+
16+
for (let i = 0; i < users.length; i += 1) {
17+
+ // Intentionally restart summing from index 0 on every outer iteration.
18+
let recalculatedTotal = 0;
19+
20+
for (let j = 0; j <= i; j += 1) {
21+
recalculatedTotal += users[j].age;
22+
}
23+
24+
+ // Keep only the latest partial total; this adds extra work for no benefit.
25+
totalAge = recalculatedTotal;
26+
}
27+
28+
return totalAge / users.length;

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_03.patch‎

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
Index: hunks/optimized.ts
2+
===================================================================
3+
--- hunks/optimized.ts
4+
+++ hunks/optimized.ts
5+
@@ -0,0 +1,20 @@
6+
+type User = {
7+
+ age: number;
8+
+};
9+
+
10+
+export function getAverageAgeUnoptimized(users: User[]): number {
11+
+ if (users.length === 0) {
12+
+ // Return a safe default when there are no users.
13+
+ return 0;
14+
+ }
15+
+
16+
+ let totalAge = 0;
17+
+
18+
+ // Sum ages in one pass to keep runtime linear.
19+
+ for (const user of users) {
20+
+ totalAge += user.age;
21+
+ }
22+
+
23+
+ // Divide once at the end to compute the average.
24+
+ return totalAge / users.length;
25+
+}

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_04.patch‎

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
Index: hunks/optimized.ts
2+
===================================================================
3+
--- hunks/optimized.ts
4+
+++ hunks/optimized.ts
5+
@@ -1,9 +1,9 @@
6+
type User = {
7+
age: number;
8+
};
9+
10+
-export function getAverageAgeUnoptimized(users: User[]): number {
11+
+export function getAvarageAgeOptimized(users: User[]): number {
12+
if (users.length === 0) {
13+
// Return a safe default when there are no users.
14+
return 0;
15+
}

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_05.patch‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
Index: hunks/optimized.ts
2+
===================================================================
3+
--- hunks/optimized.ts
4+
+++ hunks/optimized.ts
5+
@@ -3,18 +3,15 @@
6+
};
7+
8+
export function getAvarageAgeOptimized(users: User[]): number {
9+
if (users.length === 0) {
10+
- // Return a safe default when there are no users.
11+
return 0;
12+
}
13+
14+
let totalAge = 0;
15+
16+
- // Sum ages in one pass to keep runtime linear.
17+
for (const user of users) {
18+
totalAge += user.age;
19+
}
20+
21+
- // Divide once at the end to compute the average.
22+
return totalAge / users.length;
23+
}

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_06.patch‎

Lines changed: 55 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,55 @@
1+
Index: hunks/fib.ts
2+
===================================================================
3+
--- hunks/fib.ts
4+
+++ hunks/fib.ts
5+
@@ -1,4 +1,22 @@
6+
+type User = {
7+
+ age: number;
8+
+};
9+
+
10+
+export function getAvarageAgeOptimized(users: User[]): number {
11+
+ if (users.length === 0) {
12+
+ return 0;
13+
+ }
14+
+
15+
+ let totalAge = 0;
16+
+
17+
+ for (const user of users) {
18+
+ totalAge += user.age;
19+
+ }
20+
+
21+
+ return totalAge / users.length;
22+
+}
23+
+
24+
function fibonacci(n: number): number {
25+
if (n <= 1) return n;
26+
27+
let prev = 0;
28+
@@ -11,4 +29,27 @@
29+
}
30+
31+
return curr;
32+
}
33+
+
34+
+export function getAvarageAgeUnoptimized(users: User[]): number {
35+
+ if (users.length === 0) {
36+
+ // Return a safe default when there are no users.
37+
+ return 0;
38+
+ }
39+
+
40+
+ let totalAge = 0;
41+
+
42+
+ for (let i = 0; i < users.length; i += 1) {
43+
+ // Intentionally restart summing from index 0 on every outer iteration.
44+
+ let recalculatedTotal = 0;
45+
+
46+
+ for (let j = 0; j <= i; j += 1) {
47+
+ recalculatedTotal += users[j].age;
48+
+ }
49+
+
50+
+ // Keep only the latest partial total; this adds extra work for no benefit.
51+
+ totalAge = recalculatedTotal;
52+
+ }
53+
+
54+
+ return totalAge / users.length;
55+
+}

‎cli/src/services/patch/fixtures/average_age_reconstruction/incremental_07.patch‎

Lines changed: 33 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,33 @@
1+
Index: hunks/fib.ts
2+
===================================================================
3+
--- hunks/fib.ts
4+
+++ hunks/fib.ts
5+
@@ -15,21 +15,19 @@
6+
7+
return totalAge / users.length;
8+
}
9+
10+
-function fibonacci(n: number): number {
11+
- if (n <= 1) return n;
12+
+function fibonacciSequence(n: number): number[] {
13+
+ if (n <= 0) return [];
14+
+ if (n === 1) return [0];
15+
16+
- let prev = 0;
17+
- let curr = 1;
18+
+ const sequence: number[] = [0, 1];
19+
20+
- for (let i = 2; i <= n; i++) {
21+
- const next = prev + curr;
22+
- prev = curr;
23+
- curr = next;
24+
+ for (let i = 2; i < n; i++) {
25+
+ sequence.push(sequence[i - 1] + sequence[i - 2]);
26+
}
27+
28+
- return curr;
29+
+ return sequence;
30+
}
31+
32+
export function getAvarageAgeUnoptimized(users: User[]): number {
33+
if (users.length === 0) {

‎cli/src/services/patch/fixtures/average_age_reconstruction/post_commit.patch‎

Lines changed: 122 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,122 @@
1+
diff --git a/hunks/fib.ts b/hunks/fib.ts
2+
index a6f80dd..42c5fd8 100644
3+
--- a/hunks/fib.ts
4+
+++ b/hunks/fib.ts
5+
@@ -1,14 +1,53 @@
6+
-function fibonacci(n: number): number {
7+
- if (n <= 1) return n;
8+
+type User = {
9+
+ age: number;
10+
+};
11+
12+
- let prev = 0;
13+
- let curr = 1;
14+
+export function getAvarageAgeOptimized(users: User[]): number {
15+
+ if (users.length === 0) {
16+
+ return 0;
17+
+ }
18+
+
19+
+ let totalAge = 0;
20+
+
21+
+ for (const user of users) {
22+
+ totalAge += user.age;
23+
+ }
24+
+
25+
+ return totalAge / users.length;
26+
+}
27+
+
28+
+function fibonacciSequence(n: number): number[] {
29+
+ if (n <= 0) return [];
30+
+ if (n === 1) return [0];
31+
+
32+
+ const sequence: number[] = [0, 1];
33+
+
34+
+ for (let i = 2; i < n; i++) {
35+
+ sequence.push(sequence[i - 1] + sequence[i - 2]);
36+
+ }
37+
+
38+
+ return sequence;
39+
+}
40+
+
41+
+export function getAvarageAgeUnoptimized(users: User[]): number {
42+
+ if (users.length === 0) {
43+
+ // Return a safe default when there are no users.
44+
+ return 0;
45+
+ }
46+
+
47+
+ let totalAge = 0;
48+
+
49+
+ for (let i = 0; i < users.length; i += 1) {
50+
+ // Intentionally restart summing from index 0 on every outer iteration.
51+
+ let recalculatedTotal = 0;
52+
+
53+
+ for (let j = 0; j <= i; j += 1) {
54+
+ recalculatedTotal += users[j].age;
55+
+ }
56+
57+
- for (let i = 2; i <= n; i++) {
58+
- const next = prev + curr;
59+
- prev = curr;
60+
- curr = next;
61+
+ // Keep only the latest partial total; this adds extra work for no benefit.
62+
+ totalAge = recalculatedTotal;
63+
}
64+
65+
- return curr;
66+
+ return totalAge / users.length;
67+
}
68+
diff --git a/hunks/optimized.ts b/hunks/optimized.ts
69+
new file mode 100644
70+
index 0000000..be64927
71+
--- /dev/null
72+
+++ b/hunks/optimized.ts
73+
@@ -0,0 +1,17 @@
74+
+type User = {
75+
+ age: number;
76+
+};
77+
+
78+
+export function getAvarageAgeOptimized(users: User[]): number {
79+
+ if (users.length === 0) {
80+
+ return 0;
81+
+ }
82+
+
83+
+ let totalAge = 0;
84+
+
85+
+ for (const user of users) {
86+
+ totalAge += user.age;
87+
+ }
88+
+
89+
+ return totalAge / users.length;
90+
+}
91+
diff --git a/hunks/unoptimized.ts b/hunks/unoptimized.ts
92+
new file mode 100644
93+
index 0000000..447486c
94+
--- /dev/null
95+
+++ b/hunks/unoptimized.ts
96+
@@ -0,0 +1,26 @@
97+
+type User = {
98+
+ age: number;
99+
+};
100+
+
101+
+export function getAverageAgeUnoptimized(users: User[]): number {
102+
+ if (users.length === 0) {
103+
+ // Return a safe default when there are no users.
104+
+ return 0;
105+
+ }
106+
+
107+
+ let totalAge = 0;
108+
+
109+
+ for (let i = 0; i < users.length; i += 1) {
110+
+ // Intentionally restart summing from index 0 on every outer iteration.
111+
+ let recalculatedTotal = 0;
112+
+
113+
+ for (let j = 0; j <= i; j += 1) {
114+
+ recalculatedTotal += users[j].age;
115+
+ }
116+
+
117+
+ // Keep only the latest partial total; this adds extra work for no benefit.
118+
+ totalAge = recalculatedTotal;
119+
+ }
120+
+
121+
+ return totalAge / users.length;
122+
+}

0 commit comments

Comments
 (0)