[duplicates] enable duplicates analysis in PyCharm/WebStorm/PhpStorm/RubyMine
[idea/community.git] / platform / diff-impl / tests / com / intellij / diff / comparison / CharComparisonUtilTest.kt
1 /*
2  * Copyright 2000-2015 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.diff.comparison
17
18 class CharComparisonUtilTest : ComparisonUtilTestBase() {
19   fun testEqualStrings() {
20     chars {
21       ("" - "")
22       ("" - "").default()
23       testAll()
24     }
25
26     chars {
27       ("x" - "x")
28       (" " - " ").default()
29       testAll()
30     }
31
32     chars {
33       ("x_y_z_" - "x_y_z_")
34       ("      " - "      ").default()
35       testAll()
36     }
37
38     chars {
39       ("_" - "_")
40       (" " - " ").default()
41       testAll()
42     }
43
44     chars {
45       ("xxx" - "xxx")
46       ("   " - "   ").default()
47       testAll()
48     }
49
50     chars {
51       ("xyz" - "xyz")
52       ("   " - "   ").default()
53       testAll()
54     }
55
56     chars {
57       (".x!" - ".x!")
58       ("   " - "   ").default()
59       testAll()
60     }
61   }
62
63   fun testTrivialCases() {
64     chars {
65       ("x" - "")
66       ("-" - "").default()
67       testAll()
68     }
69
70     chars {
71       ("" - "x")
72       ("" - "-").default()
73       testAll()
74     }
75
76     chars {
77       ("x" - "y")
78       ("-" - "-").default()
79       testAll()
80     }
81
82     chars {
83       ("x_" - "")
84       ("--" - "").default()
85       ("- " - "").trim()
86       testAll()
87     }
88
89     chars {
90       ("" - "x_")
91       ("" - "--").default()
92       ("" - "- ").trim()
93       testAll()
94     }
95
96     chars {
97       ("x_" - "y_")
98       ("- " - "- ").default()
99       testAll()
100     }
101
102     chars {
103       ("_x" - "_y")
104       (" -" - " -").default()
105       testAll()
106     }
107   }
108
109   fun testSimpleCases() {
110     chars {
111       ("xyx" - "xxx")
112       (" - " - " - ").default()
113       testAll()
114     }
115
116     chars {
117       ("xyyx" - "xmx")
118       (" -- " - " - ").default()
119       testAll()
120     }
121
122     chars {
123       ("xyy" - "yyx")
124       ("-  " - "  -").default()
125       testAll()
126     }
127
128     chars {
129       ("x!!" - "!!x")
130       ("-  " - "  -").default()
131       testAll()
132     }
133
134     chars {
135       ("xyx" - "xx")
136       (" - " - "  ").default()
137       testAll()
138     }
139
140     chars {
141       ("xx" - "xyx")
142       ("  " - " - ").default()
143       testAll()
144     }
145
146     chars {
147       ("!..." - "...!")
148       ("-   " - "   -").default()
149       testAll()
150     }
151   }
152
153   fun testWhitespaceChangesOnly() {
154     chars {
155       (" x y z " - "xyz")
156       ("- - - -" - "   ").default()
157       ("  - -  " - "   ").trim()
158       ("       " - "   ").ignore()
159       testAll()
160     }
161
162     chars {
163       ("xyz" - " x y z ")
164       ("   " - "- - - -").default()
165       ("   " - "  - -  ").trim()
166       ("   " - "       ").ignore()
167       testAll()
168     }
169
170     chars {
171       ("x " - "x")
172       (" -" - " ").default()
173       ("  " - " ").trim()
174       testAll()
175     }
176
177     chars {
178       ("x" - " x")
179       (" " - "- ").default()
180       (" " - "  ").trim()
181       testAll()
182     }
183
184     chars {
185       (" x " - "x")
186       ("- -" - " ").default()
187       ("   " - " ").trim()
188       testAll()
189     }
190
191     chars {
192       ("x" - " x ")
193       (" " - "- -").default()
194       (" " - "   ").trim()
195       testAll()
196     }
197   }
198
199   fun testWhitespaceChanges() {
200     chars {
201       (" x " - "z")
202       ("---" - "-").default()
203       (" - " - "-").trim()
204       testAll()
205     }
206
207     chars {
208       ("x" - " z ")
209       ("-" - "---").default()
210       ("-" - " - ").trim()
211       testAll()
212     }
213
214     chars {
215       (" x" - "z\t")
216       ("--" - "-.-").default()
217       (" -" - "-. ").trim()
218       testAll()
219     }
220
221     chars {
222       ("x " - "\tz")
223       ("--" - ".--").default()
224       ("- " - ". -").trim()
225       testAll()
226     }
227
228     chars {
229       ("x y z" - "xy_z")
230       (" - - " - "  - ").default()
231       (" - - " - "    ").trim()
232       ("     " - "    ").ignore()
233       testAll()
234     }
235
236     chars {
237       ("x y \n z" - "xy\nz")
238       (" - -. - " - "  .  ").default()
239       (" -  .   " - "  .  ").trim()
240       ("    .   " - "  .  ").ignore()
241       testAll()
242     }
243   }
244
245   fun testIgnoreInnerWhitespaces() {
246     chars {
247       ("x z y" - "xmn")
248       (" ----" - " --").default()
249       ("  ---" - " --").ignore()
250       testAll()
251     }
252
253     chars {
254       ("x y z " - "x y m ")
255       ("    - " - "    - ").default()
256       testAll()
257     }
258
259     chars {
260       ("x y z" - "x y m ")
261       ("    -" - "    --").default()
262       ("    -" - "    - ").trim()
263       testAll()
264     }
265
266     chars {
267       (" x y z" - " m y z")
268       (" -    " - " -    ").default()
269       testAll()
270     }
271
272     chars {
273       ("x y z" - " m y z")
274       ("-    " - "--    ").default()
275       ("-    " - " -    ").trim()
276       testAll()
277     }
278
279     chars {
280       ("x y z" - "x m z")
281       ("  -  " - "  -  ").default()
282       testAll()
283     }
284
285     chars {
286       ("x y z" - "x  z")
287       ("  -  " - "    ").default()
288       testAll()
289     }
290
291     chars {
292       ("x  z" - "x m z")
293       ("    " - "  -  ").default()
294       testAll()
295     }
296
297     chars {
298       ("x  z" - "x n m z")
299       ("    " - "  ---  ").default()
300       testAll()
301     }
302   }
303
304   fun testEmptyRangePositions() {
305     chars {
306       ("x y" - "x zy")
307       default(ins(2, 2, 1))
308       testAll()
309     }
310
311     chars {
312       ("x y" - "xz y")
313       default(ins(1, 1, 1))
314       testAll()
315     }
316
317     chars {
318       ("x y z" - "x  z")
319       default(del(2, 2, 1))
320       testAll()
321     }
322
323     chars {
324       ("x  z" - "x m z")
325       default(ins(2, 2, 1))
326       testAll()
327     }
328
329     chars {
330       ("xyx" - "xx")
331       default(del(1, 1, 1))
332       testAll()
333     }
334
335     chars {
336       ("xx" - "xyx")
337       default(ins(1, 1, 1))
338       testAll()
339     }
340
341     chars {
342       ("xy" - "x")
343       default(del(1, 1, 1))
344       testAll()
345     }
346
347     chars {
348       ("x" - "xy")
349       default(ins(1, 1, 1))
350       testAll()
351     }
352   }
353
354   fun testAlgorithmSpecific() {
355     // This is a strange example: "ignore whitespace" produces lesser matching, than "Default".
356     // This is fine, as the main goal of "ignore whitespaces" is to reduce 'noise' of diff, and 1 change is better than 3 changes
357     // So we actually "ignore" whitespaces during comparison, rather than "mark all whitespaces as matched".
358     chars {
359       ("x   y   z" - "xX      Zz")
360       ("    -    " - " -      - ").default()
361       ("    -    " - " -------- ").ignore()
362       testAll()
363     }
364   }
365
366   fun testNonDeterministicCases() {
367     chars {
368       ("x" - "  ")
369       ignore(del(0, 0, 1))
370       testIgnore()
371     }
372
373     chars {
374       ("  " - "x")
375       ignore(ins(0, 0, 1))
376       testIgnore()
377     }
378
379     chars {
380       ("x .. z" - "x y .. z")
381       ("      " - "  --    ").default()
382       ("      " - "  -     ").ignore()
383       default(ins(2, 2, 2))
384       ignore(ins(2, 2, 1))
385       testAll()
386     }
387
388     chars {
389       (" x _ y _ z " - "x z")
390       ("-  ------ -" - "   ").default()
391       ("     -     " - "   ").trim()
392       default(del(0, 0, 1), del(3, 2, 6), del(10, 3, 1))
393       trim(del(5, 2, 1))
394       testAll()
395     }
396
397     chars {
398       ("x z" - " x _ y _ z ")
399       ("   " - "-  ------ -").default()
400       ("   " - "     -     ").trim()
401       default(ins(0, 0, 1), ins(2, 3, 6), ins(3, 10, 1))
402       trim(ins(2, 5, 1))
403       testAll()
404     }
405   }
406
407   fun testTwoSteps() {
408     chars_smart {
409       ("  a" - "a  ")
410       ("-- " - " --").default()
411       testDefault()
412     }
413
414     chars_raw {
415       ("  a" - "a  ")
416       ("  -" - "-  ").default()
417       testDefault()
418     }
419
420     chars_smart {
421       ("bba" - "abb")
422       ("  -" - "-  ").default()
423       testDefault()
424     }
425
426     chars_raw {
427       ("bba" - "abb")
428       ("  -" - "-  ").default()
429       testDefault()
430     }
431
432     chars_smart {
433       ("$chSmile$chFace $chMan" - " $chGun$chFace$chMan ")
434       ("--  -  " - "---    -").default()
435       testDefault()
436     }
437
438     chars_raw {
439       ("$chSmile$chFace $chMan" - " $chGun$chFace$chMan ")
440       ("--   --" - "---  -- ").default()
441       testDefault()
442     }
443   }
444
445   fun testHighSurrogates() {
446     chars {
447       (chSmile - chSmile)
448       ("  " - "  ").default()
449       testAll()
450     }
451
452     chars {
453       (chSmile - chMan)
454       ("--" - "--").default()
455       testAll()
456     }
457
458     chars {
459       (chSmile - chGun)
460       ("--" - "--").default()
461       testAll()
462     }
463
464     chars {
465       (chFace - chGun)
466       ("--" - "--").default()
467       testAll()
468     }
469
470     chars {
471       ("$chSmile$chGun$chMan$chFace" - "$chGun$chMan$chFace$chSmile")
472       ("--      " - "      --").default()
473       testAll()
474     }
475
476     chars {
477       (chSmile - chGun)
478       ("--" - "--").default()
479       testAll()
480     }
481
482     chars {
483       (chFace - chGun)
484       ("--" - "--").default()
485       testAll()
486     }
487
488     chars {
489       ("$chSmile " - chGun)
490       ("---" - "--").default()
491       ("-- " - "--").trim()
492       testAll()
493     }
494
495     chars {
496       (" $chSmile$chFace $chMan" - "$chGun$chFace$chMan")
497       ("---  -  " - "--    ").default()
498       (" --  -  " - "--    ").trim()
499       (" --     " - "--    ").ignore()
500       testAll()
501     }
502   }
503 }