From 014215aec525c0455b596601dd720f46c71bd469 Mon Sep 17 00:00:00 2001 From: Anna Kozlova Date: Tue, 16 Dec 2014 20:44:43 +0100 Subject: [PATCH] generated test data, unrelated classes --- .../UnrelatedClasses.java | 2146 +++++++++++++++++ .../GenericsHighlightingGenerated8Test.java | 49 + 2 files changed, 2195 insertions(+) create mode 100644 java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlightingGenerated8/UnrelatedClasses.java create mode 100644 java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlightingGenerated8Test.java diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlightingGenerated8/UnrelatedClasses.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlightingGenerated8/UnrelatedClasses.java new file mode 100644 index 000000000000..cf8829ea3575 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlightingGenerated8/UnrelatedClasses.java @@ -0,0 +1,2146 @@ +class B {} +abstract class A { + + + void baz1(B a) {} + abstract B foo1(); + void bar1(A a){ + baz1(a.foo1()); + } + + + void baz2(B a) {} + abstract B foo2(); + void bar2(A a){ + baz2(a.foo2()); + } + + + void baz3(B a) {} + abstract B foo3(); + void bar3(A a){ + baz3(a.foo3()); + } + + + void baz4(B a) {} + abstract B foo4(); + void bar4(A a){ + baz4(a.foo4()); + } + + + void baz5(B a) {} + abstract B foo5(); + void bar5(A a){ + baz5(a.foo5()); + } + + + void baz6(B a) {} + abstract B foo6(); + void bar6(A a){ + baz6(a.foo6()); + } + + + void baz7(B a) {} + abstract B foo7(); + void bar7(A a){ + baz7(a.foo7()); + } + + + void baz8(B a) {} + abstract B foo8(); + void bar8(A a){ + baz8(a.foo8()); + } + + + void baz9(B a) {} + abstract B foo9(); + void bar9(A a){ + baz9(a.foo9()); + } + + + void baz10(B a) {} + abstract B foo10(); + void bar10(A a){ + baz10(a.foo10()); + } + + + void baz11(B a) {} + abstract B foo11(); + void bar11(A a){ + baz11(a.foo11()); + } + + + void baz12(B a) {} + abstract B foo12(); + void bar12(A a){ + baz12(a.foo12()); + } + + + void baz13(B a) {} + abstract B foo13(); + void bar13(A a){ + baz13(a.foo13()); + } + + + void baz14(B a) {} + abstract B foo14(); + void bar14(A a){ + baz14(a.foo14()); + } + + + void baz15(B a) {} + abstract B foo15(); + void bar15(A a){ + baz15(a.foo15()); + } + + + void baz16(B a) {} + abstract B foo16(); + void bar16(A a){ + baz16(a.foo16()); + } + + + void baz17(B a) {} + abstract B foo17(); + void bar17(A a){ + baz17(a.foo17()); + } + + + void baz18(B a) {} + abstract B foo18(); + void bar18(A a){ + baz18(a.foo18()); + } + + + void baz19(B a) {} + abstract B foo19(); + void bar19(A a){ + baz19(a.foo19()); + } + + + void baz20(B a) {} + abstract B foo20(); + void bar20(A a){ + baz20(a.foo20()); + } + + + void baz21(B a) {} + abstract B foo21(); + void bar21(A a){ + baz21(a.foo21()); + } + + + void baz22(B a) {} + abstract B foo22(); + void bar22(A a){ + baz22(a.foo22()); + } + + + void baz23(B a) {} + abstract B foo23(); + void bar23(A a){ + baz23(a.foo23()); + } + + + void baz24(B a) {} + abstract B foo24(); + void bar24(A a){ + baz24(a.foo24()); + } + + + void baz25(B a) {} + abstract B foo25(); + void bar25(A a){ + baz25(a.foo25()); + } + + + void baz26(B a) {} + abstract B foo26(); + void bar26(A a){ + baz26(a.foo26()); + } + + + void baz27(B a) {} + abstract B foo27(); + void bar27(A a){ + baz27(a.foo27()); + } + + + void baz28(B a) {} + abstract B foo28(); + void bar28(A a){ + baz28(a.foo28()); + } + + + void baz29(B a) {} + abstract B foo29(); + void bar29(A a){ + baz29(a.foo29()); + } + + + void baz30(B a) {} + abstract B foo30(); + void bar30(A a){ + baz30(a.foo30()); + } + + + void baz31(B a) {} + abstract B foo31(); + void bar31(A a){ + baz31(a.foo31()); + } + + + void baz32(B a) {} + abstract B foo32(); + void bar32(A a){ + baz32(a.foo32()); + } + + + void baz33(B a) {} + abstract B foo33(); + void bar33(A a){ + baz33(a.foo33()); + } + + + void baz34(B a) {} + abstract B foo34(); + void bar34(A a){ + baz34(a.foo34()); + } + + + void baz35(B a) {} + abstract B foo35(); + void bar35(A a){ + baz35(a.foo35()); + } + + + void baz36(B a) {} + abstract B foo36(); + void bar36(A a){ + baz36(a.foo36()); + } + + + void baz37(B a) {} + abstract B foo37(); + void bar37(A a){ + baz37(a.foo37()); + } + + + void baz38(B a) {} + abstract B foo38(); + void bar38(A a){ + baz38(a.foo38()); + } + + + void baz39(B a) {} + abstract B foo39(); + void bar39(A a){ + baz39(a.foo39()); + } + + + void baz40(B a) {} + abstract B foo40(); + void bar40(A a){ + baz40(a.foo40()); + } + + + void baz41(B a) {} + abstract B foo41(); + void bar41(A a){ + baz41(a.foo41()); + } + + + void baz42(B a) {} + abstract B foo42(); + void bar42(A a){ + baz42(a.foo42()); + } + + + void baz43(B a) {} + abstract B foo43(); + void bar43(A a){ + baz43(a.foo43()); + } + + + void baz44(B a) {} + abstract B foo44(); + void bar44(A a){ + baz44(a.foo44()); + } + + + void baz45(B a) {} + abstract B foo45(); + void bar45(A a){ + baz45(a.foo45()); + } + + + void baz46(B a) {} + abstract B foo46(); + void bar46(A a){ + baz46(a.foo46()); + } + + + void baz47(B a) {} + abstract B foo47(); + void bar47(A a){ + baz47(a.foo47()); + } + + + void baz48(B a) {} + abstract B foo48(); + void bar48(A a){ + baz48(a.foo48()); + } + + + void baz49(B a) {} + abstract B foo49(); + void bar49(A a){ + baz49(a.foo49()); + } + + + void baz50(B a) {} + abstract B foo50(); + void bar50(A a){ + baz50(a.foo50()); + } + + + void baz51(B a) {} + abstract B foo51(); + void bar51(A a){ + baz51(a.foo51()); + } + + + void baz52(B a) {} + abstract B foo52(); + void bar52(A a){ + baz52(a.foo52()); + } + + + void baz53(B a) {} + abstract B foo53(); + void bar53(A a){ + baz53(a.foo53()); + } + + + void baz54(B a) {} + abstract B foo54(); + void bar54(A a){ + baz54(a.foo54()); + } + + + void baz55(B a) {} + abstract B foo55(); + void bar55(A a){ + baz55(a.foo55()); + } + + + void baz56(B a) {} + abstract B foo56(); + void bar56(A a){ + baz56(a.foo56()); + } + + + void baz57(B a) {} + abstract B foo57(); + void bar57(A a){ + baz57(a.foo57()); + } + + + void baz58(B a) {} + abstract B foo58(); + void bar58(A a){ + baz58(a.foo58()); + } + + + void baz59(B a) {} + abstract B foo59(); + void bar59(A a){ + baz59(a.foo59()); + } + + + void baz60(B a) {} + abstract B foo60(); + void bar60(A a){ + baz60(a.foo60()); + } + + + void baz61(B a) {} + abstract B foo61(); + void bar61(A a){ + baz61(a.foo61()); + } + + + void baz62(B a) {} + abstract B foo62(); + void bar62(A a){ + baz62(a.foo62()); + } + + + void baz63(B a) {} + abstract B foo63(); + void bar63(A a){ + baz63(a.foo63()); + } + + + void baz64(B a) {} + abstract B foo64(); + void bar64(A a){ + baz64(a.foo64()); + } + + + void baz65(B a) {} + abstract B foo65(); + void bar65(A a){ + baz65(a.foo65()); + } + + + void baz66(B a) {} + abstract B foo66(); + void bar66(A a){ + baz66(a.foo66()); + } + + + void baz67(B a) {} + abstract B foo67(); + void bar67(A a){ + baz67(a.foo67()); + } + + + void baz68(B a) {} + abstract B foo68(); + void bar68(A a){ + baz68(a.foo68()); + } + + + void baz69(B a) {} + abstract B foo69(); + void bar69(A a){ + baz69(a.foo69()); + } + + + void baz70(B a) {} + abstract B foo70(); + void bar70(A a){ + baz70(a.foo70()); + } + + + void baz71(B a) {} + abstract B foo71(); + void bar71(A a){ + baz71(a.foo71()); + } + + + void baz72(B a) {} + abstract B foo72(); + void bar72(A a){ + baz72(a.foo72()); + } + + + void baz73(B a) {} + abstract B foo73(); + void bar73(A a){ + baz73(a.foo73()); + } + + + void baz74(B a) {} + abstract B foo74(); + void bar74(A a){ + baz74(a.foo74()); + } + + + void baz75(B a) {} + abstract B foo75(); + void bar75(A a){ + baz75(a.foo75()); + } + + + void baz76(B a) {} + abstract B foo76(); + void bar76(A a){ + baz76(a.foo76()); + } + + + void baz77(B a) {} + abstract B foo77(); + void bar77(A a){ + baz77(a.foo77()); + } + + + void baz78(B a) {} + abstract B foo78(); + void bar78(A a){ + baz78(a.foo78()); + } + + + void baz79(B a) {} + abstract B foo79(); + void bar79(A a){ + baz79(a.foo79()); + } + + + void baz80(B a) {} + abstract B foo80(); + void bar80(A a){ + baz80(a.foo80()); + } + + + void baz81(B a) {} + abstract B foo81(); + void bar81(A a){ + baz81(a.foo81()); + } + + + void baz82(B a) {} + abstract B foo82(); + void bar82(A a){ + baz82(a.foo82()); + } + + + void baz83(B a) {} + abstract B foo83(); + void bar83(A a){ + baz83(a.foo83()); + } + + + void baz84(B a) {} + abstract B foo84(); + void bar84(A a){ + baz84(a.foo84()); + } + + + void baz85(B a) {} + abstract B foo85(); + void bar85(A a){ + baz85(a.foo85()); + } + + + void baz86(B a) {} + abstract B foo86(); + void bar86(A a){ + baz86(a.foo86()); + } + + + void baz87(B a) {} + abstract B foo87(); + void bar87(A a){ + baz87(a.foo87()); + } + + + void baz88(B a) {} + abstract B foo88(); + void bar88(A a){ + baz88(a.foo88()); + } + + + void baz89(B a) {} + abstract B foo89(); + void bar89(A a){ + baz89(a.foo89()); + } + + + void baz90(B a) {} + abstract B foo90(); + void bar90(A a){ + baz90(a.foo90()); + } + + + void baz91(B a) {} + abstract B foo91(); + void bar91(A a){ + baz91(a.foo91()); + } + + + void baz92(B a) {} + abstract B foo92(); + void bar92(A a){ + baz92(a.foo92()); + } + + + void baz93(B a) {} + abstract B foo93(); + void bar93(A a){ + baz93(a.foo93()); + } + + + void baz94(B a) {} + abstract B foo94(); + void bar94(A a){ + baz94(a.foo94()); + } + + + void baz95(B a) {} + abstract B foo95(); + void bar95(A a){ + baz95(a.foo95()); + } + + + void baz96(B a) {} + abstract B foo96(); + void bar96(A a){ + baz96(a.foo96()); + } + + + void baz97(B a) {} + abstract B foo97(); + void bar97(A a){ + baz97(a.foo97()); + } + + + void baz98(B a) {} + abstract B foo98(); + void bar98(A a){ + baz98(a.foo98()); + } + + + void baz99(B a) {} + abstract B foo99(); + void bar99(A a){ + baz99(a.foo99()); + } + + + void baz100(B a) {} + abstract B foo100(); + void bar100(A a){ + baz100(a.foo100()); + } + + + void baz101(B a) {} + abstract B foo101(); + void bar101(A a){ + baz101(a.foo101()); + } + + + void baz102(B a) {} + abstract B foo102(); + void bar102(A a){ + baz102(a.foo102()); + } + + + void baz103(B a) {} + abstract B foo103(); + void bar103(A a){ + baz103(a.foo103()); + } + + + void baz104(B a) {} + abstract B foo104(); + void bar104(A a){ + baz104(a.foo104()); + } + + + void baz105(B a) {} + abstract B foo105(); + void bar105(A a){ + baz105(a.foo105()); + } + + + void baz106(B a) {} + abstract B foo106(); + void bar106(A a){ + baz106(a.foo106()); + } + + + void baz107(B a) {} + abstract B foo107(); + void bar107(A a){ + baz107(a.foo107()); + } + + + void baz108(B a) {} + abstract B foo108(); + void bar108(A a){ + baz108(a.foo108()); + } + + + void baz109(B a) {} + abstract B foo109(); + void bar109(A a){ + baz109(a.foo109()); + } + + + void baz110(B a) {} + abstract B foo110(); + void bar110(A a){ + baz110(a.foo110()); + } + + + void baz111(B a) {} + abstract B foo111(); + void bar111(A a){ + baz111(a.foo111()); + } + + + void baz112(B a) {} + abstract B foo112(); + void bar112(A a){ + baz112(a.foo112()); + } + + + void baz113(B a) {} + abstract B foo113(); + void bar113(A a){ + baz113(a.foo113()); + } + + + void baz114(B a) {} + abstract B foo114(); + void bar114(A a){ + baz114(a.foo114()); + } + + + void baz115(B a) {} + abstract B foo115(); + void bar115(A a){ + baz115(a.foo115()); + } + + + void baz116(B a) {} + abstract B foo116(); + void bar116(A a){ + baz116(a.foo116()); + } + + + void baz117(B a) {} + abstract B foo117(); + void bar117(A a){ + baz117(a.foo117()); + } + + + void baz118(B a) {} + abstract B foo118(); + void bar118(A a){ + baz118(a.foo118()); + } + + + void baz119(B a) {} + abstract B foo119(); + void bar119(A a){ + baz119(a.foo119()); + } + + + void baz120(B a) {} + abstract B foo120(); + void bar120(A a){ + baz120(a.foo120()); + } + + + void baz121(B a) {} + abstract B foo121(); + void bar121(A a){ + baz121(a.foo121()); + } + + + void baz122(B a) {} + abstract B foo122(); + void bar122(A a){ + baz122(a.foo122()); + } + + + void baz123(B a) {} + abstract B foo123(); + void bar123(A a){ + baz123(a.foo123()); + } + + + void baz124(B a) {} + abstract B foo124(); + void bar124(A a){ + baz124(a.foo124()); + } + + + void baz125(B a) {} + abstract B foo125(); + void bar125(A a){ + baz125(a.foo125()); + } + + + void baz126(B a) {} + abstract B foo126(); + void bar126(A a){ + baz126(a.foo126()); + } + + + void baz127(B a) {} + abstract B foo127(); + void bar127(A a){ + baz127(a.foo127()); + } + + + void baz128(B a) {} + abstract B foo128(); + void bar128(A a){ + baz128(a.foo128()); + } + + + void baz129(B a) {} + abstract B foo129(); + void bar129(A a){ + baz129(a.foo129()); + } + + + void baz130(B a) {} + abstract B foo130(); + void bar130(A a){ + baz130(a.foo130()); + } + + + void baz131(B a) {} + abstract B foo131(); + void bar131(A a){ + baz131(a.foo131()); + } + + + void baz132(B a) {} + abstract B foo132(); + void bar132(A a){ + baz132(a.foo132()); + } + + + void baz133(B a) {} + abstract B foo133(); + void bar133(A a){ + baz133(a.foo133()); + } + + + void baz134(B a) {} + abstract B foo134(); + void bar134(A a){ + baz134(a.foo134()); + } + + + void baz135(B a) {} + abstract B foo135(); + void bar135(A a){ + baz135(a.foo135()); + } + + + void baz136(B a) {} + abstract B foo136(); + void bar136(A a){ + baz136(a.foo136()); + } + + + void baz137(B a) {} + abstract B foo137(); + void bar137(A a){ + baz137(a.foo137()); + } + + + void baz138(B a) {} + abstract B foo138(); + void bar138(A a){ + baz138(a.foo138()); + } + + + void baz139(B a) {} + abstract B foo139(); + void bar139(A a){ + baz139(a.foo139()); + } + + + void baz140(B a) {} + abstract B foo140(); + void bar140(A a){ + baz140(a.foo140()); + } + + + void baz141(B a) {} + abstract B foo141(); + void bar141(A a){ + baz141(a.foo141()); + } + + + void baz142(B a) {} + abstract B foo142(); + void bar142(A a){ + baz142(a.foo142()); + } + + + void baz143(B a) {} + abstract B foo143(); + void bar143(A a){ + baz143(a.foo143()); + } + + + void baz144(B a) {} + abstract B foo144(); + void bar144(A a){ + baz144(a.foo144()); + } + + + void baz145(B a) {} + abstract B foo145(); + void bar145(A a){ + baz145(a.foo145()); + } + + + void baz146(B a) {} + abstract B foo146(); + void bar146(A a){ + baz146(a.foo146()); + } + + + void baz147(B a) {} + abstract B foo147(); + void bar147(A a){ + baz147(a.foo147()); + } + + + void baz148(B a) {} + abstract B foo148(); + void bar148(A a){ + baz148(a.foo148()); + } + + + void baz149(B a) {} + abstract B foo149(); + void bar149(A a){ + baz149(a.foo149()); + } + + + void baz150(B a) {} + abstract B foo150(); + void bar150(A a){ + baz150(a.foo150()); + } + + + void baz151(B a) {} + abstract B foo151(); + void bar151(A a){ + baz151(a.foo151()); + } + + + void baz152(B a) {} + abstract B foo152(); + void bar152(A a){ + baz152(a.foo152()); + } + + + void baz153(B a) {} + abstract B foo153(); + void bar153(A a){ + baz153(a.foo153()); + } + + + void baz154(B a) {} + abstract B foo154(); + void bar154(A a){ + baz154(a.foo154()); + } + + + void baz155(B a) {} + abstract B foo155(); + void bar155(A a){ + baz155(a.foo155()); + } + + + void baz156(B a) {} + abstract B foo156(); + void bar156(A a){ + baz156(a.foo156()); + } + + + void baz157(B a) {} + abstract B foo157(); + void bar157(A a){ + baz157(a.foo157()); + } + + + void baz158(B a) {} + abstract B foo158(); + void bar158(A a){ + baz158(a.foo158()); + } + + + void baz159(B a) {} + abstract B foo159(); + void bar159(A a){ + baz159(a.foo159()); + } + + + void baz160(B a) {} + abstract B foo160(); + void bar160(A a){ + baz160(a.foo160()); + } + + + void baz161(B a) {} + abstract B foo161(); + void bar161(A a){ + baz161(a.foo161()); + } + + + void baz162(B a) {} + abstract B foo162(); + void bar162(A a){ + baz162(a.foo162()); + } + + + void baz163(B a) {} + abstract B foo163(); + void bar163(A a){ + baz163(a.foo163()); + } + + + void baz164(B a) {} + abstract B foo164(); + void bar164(A a){ + baz164(a.foo164()); + } + + + void baz165(B a) {} + abstract B foo165(); + void bar165(A a){ + baz165(a.foo165()); + } + + + void baz166(B a) {} + abstract B foo166(); + void bar166(A a){ + baz166(a.foo166()); + } + + + void baz167(B a) {} + abstract B foo167(); + void bar167(A a){ + baz167(a.foo167()); + } + + + void baz168(B a) {} + abstract B foo168(); + void bar168(A a){ + baz168(a.foo168()); + } + + + void baz169(B a) {} + abstract B foo169(); + void bar169(A a){ + baz169(a.foo169()); + } + + + void baz170(B a) {} + abstract B foo170(); + void bar170(A a){ + baz170(a.foo170()); + } + + + void baz171(B a) {} + abstract B foo171(); + void bar171(A a){ + baz171(a.foo171()); + } + + + void baz172(B a) {} + abstract B foo172(); + void bar172(A a){ + baz172(a.foo172()); + } + + + void baz173(B a) {} + abstract B foo173(); + void bar173(A a){ + baz173(a.foo173()); + } + + + void baz174(B a) {} + abstract B foo174(); + void bar174(A a){ + baz174(a.foo174()); + } + + + void baz175(B a) {} + abstract B foo175(); + void bar175(A a){ + baz175(a.foo175()); + } + + + void baz176(B a) {} + abstract B foo176(); + void bar176(A a){ + baz176(a.foo176()); + } + + + void baz177(B a) {} + abstract B foo177(); + void bar177(A a){ + baz177(a.foo177()); + } + + + void baz178(B a) {} + abstract B foo178(); + void bar178(A a){ + baz178(a.foo178()); + } + + + void baz179(B a) {} + abstract B foo179(); + void bar179(A a){ + baz179(a.foo179()); + } + + + void baz180(B a) {} + abstract B foo180(); + void bar180(A a){ + baz180(a.foo180()); + } + + + void baz181(B a) {} + abstract B foo181(); + void bar181(A a){ + baz181(a.foo181()); + } + + + void baz182(B a) {} + abstract B foo182(); + void bar182(A a){ + baz182(a.foo182()); + } + + + void baz183(B a) {} + abstract B foo183(); + void bar183(A a){ + baz183(a.foo183()); + } + + + void baz184(B a) {} + abstract B foo184(); + void bar184(A a){ + baz184(a.foo184()); + } + + + void baz185(B a) {} + abstract B foo185(); + void bar185(A a){ + baz185(a.foo185()); + } + + + void baz186(B a) {} + abstract B foo186(); + void bar186(A a){ + baz186(a.foo186()); + } + + + void baz187(B a) {} + abstract B foo187(); + void bar187(A a){ + baz187(a.foo187()); + } + + + void baz188(B a) {} + abstract B foo188(); + void bar188(A a){ + baz188(a.foo188()); + } + + + void baz189(B a) {} + abstract B foo189(); + void bar189(A a){ + baz189(a.foo189()); + } + + + void baz190(B a) {} + abstract B foo190(); + void bar190(A a){ + baz190(a.foo190()); + } + + + void baz191(B a) {} + abstract B foo191(); + void bar191(A a){ + baz191(a.foo191()); + } + + + void baz192(B a) {} + abstract B foo192(); + void bar192(A a){ + baz192(a.foo192()); + } + + + void baz193(B a) {} + abstract B foo193(); + void bar193(A a){ + baz193(a.foo193()); + } + + + void baz194(B a) {} + abstract B foo194(); + void bar194(A a){ + baz194(a.foo194()); + } + + + void baz195(B a) {} + abstract B foo195(); + void bar195(A a){ + baz195(a.foo195()); + } + + + void baz196(B a) {} + abstract B foo196(); + void bar196(A a){ + baz196(a.foo196()); + } + + + void baz197(B a) {} + abstract B foo197(); + void bar197(A a){ + baz197(a.foo197()); + } + + + void baz198(B a) {} + abstract B foo198(); + void bar198(A a){ + baz198(a.foo198()); + } + + + void baz199(B a) {} + abstract B foo199(); + void bar199(A a){ + baz199(a.foo199()); + } + + + void baz200(B a) {} + abstract B foo200(); + void bar200(A a){ + baz200(a.foo200()); + } + + + void baz201(B a) {} + abstract B foo201(); + void bar201(A a){ + baz201(a.foo201()); + } + + + void baz202(B a) {} + abstract B foo202(); + void bar202(A a){ + baz202(a.foo202()); + } + + + void baz203(B a) {} + abstract B foo203(); + void bar203(A a){ + baz203(a.foo203()); + } + + + void baz204(B a) {} + abstract B foo204(); + void bar204(A a){ + baz204(a.foo204()); + } + + + void baz205(B a) {} + abstract B foo205(); + void bar205(A a){ + baz205(a.foo205()); + } + + + void baz206(B a) {} + abstract B foo206(); + void bar206(A a){ + baz206(a.foo206()); + } + + + void baz207(B a) {} + abstract B foo207(); + void bar207(A a){ + baz207(a.foo207()); + } + + + void baz208(B a) {} + abstract B foo208(); + void bar208(A a){ + baz208(a.foo208()); + } + + + void baz209(B a) {} + abstract B foo209(); + void bar209(A a){ + baz209(a.foo209()); + } + + + void baz210(B a) {} + abstract B foo210(); + void bar210(A a){ + baz210(a.foo210()); + } + + + void baz211(B a) {} + abstract B foo211(); + void bar211(A a){ + baz211(a.foo211()); + } + + + void baz212(B a) {} + abstract B foo212(); + void bar212(A a){ + baz212(a.foo212()); + } + + + void baz213(B a) {} + abstract B foo213(); + void bar213(A a){ + baz213(a.foo213()); + } + + + void baz214(B a) {} + abstract B foo214(); + void bar214(A a){ + baz214(a.foo214()); + } + + + void baz215(B a) {} + abstract B foo215(); + void bar215(A a){ + baz215(a.foo215()); + } + + + void baz216(B a) {} + abstract B foo216(); + void bar216(A a){ + baz216(a.foo216()); + } + + + void baz217(B a) {} + abstract B foo217(); + void bar217(A a){ + baz217(a.foo217()); + } + + + void baz218(B a) {} + abstract B foo218(); + void bar218(A a){ + baz218(a.foo218()); + } + + + void baz219(B a) {} + abstract B foo219(); + void bar219(A a){ + baz219(a.foo219()); + } + + + void baz220(B a) {} + abstract B foo220(); + void bar220(A a){ + baz220(a.foo220()); + } + + + void baz221(B a) {} + abstract B foo221(); + void bar221(A a){ + baz221(a.foo221()); + } + + + void baz222(B a) {} + abstract B foo222(); + void bar222(A a){ + baz222(a.foo222()); + } + + + void baz223(B a) {} + abstract B foo223(); + void bar223(A a){ + baz223(a.foo223()); + } + + + void baz224(B a) {} + abstract B foo224(); + void bar224(A a){ + baz224(a.foo224()); + } + + + void baz225(B a) {} + abstract B foo225(); + void bar225(A a){ + baz225(a.foo225()); + } + + + void baz226(B a) {} + abstract B foo226(); + void bar226(A a){ + baz226(a.foo226()); + } + + + void baz227(B a) {} + abstract B foo227(); + void bar227(A a){ + baz227(a.foo227()); + } + + + void baz228(B a) {} + abstract B foo228(); + void bar228(A a){ + baz228(a.foo228()); + } + + + void baz229(B a) {} + abstract B foo229(); + void bar229(A a){ + baz229(a.foo229()); + } + + + void baz230(B a) {} + abstract B foo230(); + void bar230(A a){ + baz230(a.foo230()); + } + + + void baz231(B a) {} + abstract B foo231(); + void bar231(A a){ + baz231(a.foo231()); + } + + + void baz232(B a) {} + abstract B foo232(); + void bar232(A a){ + baz232(a.foo232()); + } + + + void baz233(B a) {} + abstract B foo233(); + void bar233(A a){ + baz233(a.foo233()); + } + + + void baz234(B a) {} + abstract B foo234(); + void bar234(A a){ + baz234(a.foo234()); + } + + + void baz235(B a) {} + abstract B foo235(); + void bar235(A a){ + baz235(a.foo235()); + } + + + void baz236(B a) {} + abstract B foo236(); + void bar236(A a){ + baz236(a.foo236()); + } + + + void baz237(B a) {} + abstract B foo237(); + void bar237(A a){ + baz237(a.foo237()); + } + + + void baz238(B a) {} + abstract B foo238(); + void bar238(A a){ + baz238(a.foo238()); + } + + + void baz239(B a) {} + abstract B foo239(); + void bar239(A a){ + baz239(a.foo239()); + } + + + void baz240(B a) {} + abstract B foo240(); + void bar240(A a){ + baz240(a.foo240()); + } + + + void baz241(B a) {} + abstract B foo241(); + void bar241(A a){ + baz241(a.foo241()); + } + + + void baz242(B a) {} + abstract B foo242(); + void bar242(A a){ + baz242(a.foo242()); + } + + + void baz243(B a) {} + abstract B foo243(); + void bar243(A a){ + baz243(a.foo243()); + } + + + void baz244(B a) {} + abstract B foo244(); + void bar244(A a){ + baz244(a.foo244()); + } + + + void baz245(B a) {} + abstract B foo245(); + void bar245(A a){ + baz245(a.foo245()); + } + + + void baz246(B a) {} + abstract B foo246(); + void bar246(A a){ + baz246(a.foo246()); + } + + + void baz247(B a) {} + abstract B foo247(); + void bar247(A a){ + baz247(a.foo247()); + } + + + void baz248(B a) {} + abstract B foo248(); + void bar248(A a){ + baz248(a.foo248()); + } + + + void baz249(B a) {} + abstract B foo249(); + void bar249(A a){ + baz249(a.foo249()); + } + + + void baz250(B a) {} + abstract B foo250(); + void bar250(A a){ + baz250(a.foo250()); + } + + + void baz251(B a) {} + abstract B foo251(); + void bar251(A a){ + baz251(a.foo251()); + } + + + void baz252(B a) {} + abstract B foo252(); + void bar252(A a){ + baz252(a.foo252()); + } + + + void baz253(B a) {} + abstract B foo253(); + void bar253(A a){ + baz253(a.foo253()); + } + + + void baz254(B a) {} + abstract B foo254(); + void bar254(A a){ + baz254(a.foo254()); + } + + + void baz255(B a) {} + abstract B foo255(); + void bar255(A a){ + baz255(a.foo255()); + } + + + void baz256(B a) {} + abstract B foo256(); + void bar256(A a){ + baz256(a.foo256()); + } + + + void baz257(B a) {} + abstract B foo257(); + void bar257(A a){ + baz257(a.foo257()); + } + + + void baz258(B a) {} + abstract B foo258(); + void bar258(A a){ + baz258(a.foo258()); + } + + + void baz259(B a) {} + abstract B foo259(); + void bar259(A a){ + baz259(a.foo259()); + } + + + void baz260(B a) {} + abstract B foo260(); + void bar260(A a){ + baz260(a.foo260()); + } + + + void baz261(B a) {} + abstract B foo261(); + void bar261(A a){ + baz261(a.foo261()); + } + + + void baz262(B a) {} + abstract B foo262(); + void bar262(A a){ + baz262(a.foo262()); + } + + + void baz263(B a) {} + abstract B foo263(); + void bar263(A a){ + baz263(a.foo263()); + } + + + void baz264(B a) {} + abstract B foo264(); + void bar264(A a){ + baz264(a.foo264()); + } + + + void baz265(B a) {} + abstract B foo265(); + void bar265(A a){ + baz265(a.foo265()); + } + + + void baz266(B a) {} + abstract B foo266(); + void bar266(A a){ + baz266(a.foo266()); + } + + + void baz267(B a) {} + abstract B foo267(); + void bar267(A a){ + baz267(a.foo267()); + } + + + void baz268(B a) {} + abstract B foo268(); + void bar268(A a){ + baz268(a.foo268()); + } + + + void baz269(B a) {} + abstract B foo269(); + void bar269(A a){ + baz269(a.foo269()); + } + + + void baz270(B a) {} + abstract B foo270(); + void bar270(A a){ + baz270(a.foo270()); + } + + + void baz271(B a) {} + abstract B foo271(); + void bar271(A a){ + baz271(a.foo271()); + } + + + void baz272(B a) {} + abstract B foo272(); + void bar272(A a){ + baz272(a.foo272()); + } + + + void baz273(B a) {} + abstract B foo273(); + void bar273(A a){ + baz273(a.foo273()); + } + + + void baz274(B a) {} + abstract B foo274(); + void bar274(A a){ + baz274(a.foo274()); + } + + + void baz275(B a) {} + abstract B foo275(); + void bar275(A a){ + baz275(a.foo275()); + } + + + void baz276(B a) {} + abstract B foo276(); + void bar276(A a){ + baz276(a.foo276()); + } + + + void baz277(B a) {} + abstract B foo277(); + void bar277(A a){ + baz277(a.foo277()); + } + + + void baz278(B a) {} + abstract B foo278(); + void bar278(A a){ + baz278(a.foo278()); + } + + + void baz279(B a) {} + abstract B foo279(); + void bar279(A a){ + baz279(a.foo279()); + } + + + void baz280(B a) {} + abstract B foo280(); + void bar280(A a){ + baz280(a.foo280()); + } + + + void baz281(B a) {} + abstract B foo281(); + void bar281(A a){ + baz281(a.foo281()); + } + + + void baz282(B a) {} + abstract B foo282(); + void bar282(A a){ + baz282(a.foo282()); + } + + + void baz283(B a) {} + abstract B foo283(); + void bar283(A a){ + baz283(a.foo283()); + } + + + void baz284(B a) {} + abstract B foo284(); + void bar284(A a){ + baz284(a.foo284()); + } + + + void baz285(B a) {} + abstract B foo285(); + void bar285(A a){ + baz285(a.foo285()); + } + + + void baz286(B a) {} + abstract B foo286(); + void bar286(A a){ + baz286(a.foo286()); + } + + + void baz287(B a) {} + abstract B foo287(); + void bar287(A a){ + baz287(a.foo287()); + } + + + void baz288(B a) {} + abstract B foo288(); + void bar288(A a){ + baz288(a.foo288()); + } + + + void baz289(B a) {} + abstract B foo289(); + void bar289(A a){ + baz289(a.foo289()); + } + + + void baz290(B a) {} + abstract B foo290(); + void bar290(A a){ + baz290(a.foo290()); + } + + + void baz291(B a) {} + abstract B foo291(); + void bar291(A a){ + baz291(a.foo291()); + } + + + void baz292(B a) {} + abstract B foo292(); + void bar292(A a){ + baz292(a.foo292()); + } + + + void baz293(B a) {} + abstract B foo293(); + void bar293(A a){ + baz293(a.foo293()); + } + + + void baz294(B a) {} + abstract B foo294(); + void bar294(A a){ + baz294(a.foo294()); + } + + + void baz295(B a) {} + abstract B foo295(); + void bar295(A a){ + baz295(a.foo295()); + } + + + void baz296(B a) {} + abstract B foo296(); + void bar296(A a){ + baz296(a.foo296()); + } + + + void baz297(B a) {} + abstract B foo297(); + void bar297(A a){ + baz297(a.foo297()); + } + + + void baz298(B a) {} + abstract B foo298(); + void bar298(A a){ + baz298(a.foo298()); + } + + + void baz299(B a) {} + abstract B foo299(); + void bar299(A a){ + baz299(a.foo299()); + } + + + void baz300(B a) {} + abstract B foo300(); + void bar300(A a){ + baz300(a.foo300()); + } + + /* + //generation method + public static void main(String[] args) { + String prefix = "class B {}\n" + + "abstract class A {\n"; + String template = " void baz$N$(B<$K1$, $K2$> a) {}\n" + + " abstract B<$T1$,$T2$> foo$N$();\n" + + " void bar$N$(A<$A1$> a){\n" + + " baz$N$(a.foo$N$());\n" + + " }\n"; + String suffix = "}"; + + String[] k = {"K", "? extends K", "? super K", "?"}; + String[] t = {"T", "? extends T", "? super T", "?"}; + String[] a = {"? extends T", "? super T", "?"}; + + System.out.println(prefix); + int n = 1; + for (int ki = 0; ki < k.length; ki++) { + String k1 = k[ki]; + for (int kki = ki; kki < k.length; kki++) { + String k2 = k[kki]; + for (int i = 0; i < t.length; i++) { + String t1 = t[i]; + for (int it = i; it < t.length; it++) { + String t2 = t[it]; + for (String a1 : a) { + System.out.println(); + System.out.println( + template.replaceAll("\\$K1\\$", k1) + .replaceAll("\\$K2\\$", k2) + .replaceAll("\\$T1\\$", t1) + .replaceAll("\\$T2\\$", t2) + .replaceAll("\\$A1\\$", a1) + .replaceAll("\\$N\\$", String.valueOf(n++))); + } + } + } + } + } + System.out.println(suffix); + }*/ +} diff --git a/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlightingGenerated8Test.java b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlightingGenerated8Test.java new file mode 100644 index 000000000000..5139a68c9f1b --- /dev/null +++ b/java/java-tests/testSrc/com/intellij/codeInsight/daemon/lambda/GenericsHighlightingGenerated8Test.java @@ -0,0 +1,49 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.codeInsight.daemon.lambda; + +import com.intellij.codeInsight.daemon.LightDaemonAnalyzerTestCase; +import com.intellij.idea.Bombed; +import com.intellij.openapi.projectRoots.JavaSdkVersion; +import com.intellij.openapi.projectRoots.Sdk; +import com.intellij.openapi.roots.LanguageLevelProjectExtension; +import com.intellij.pom.java.LanguageLevel; +import com.intellij.testFramework.IdeaTestUtil; +import org.jetbrains.annotations.NonNls; + +import java.util.Calendar; + +public class GenericsHighlightingGenerated8Test extends LightDaemonAnalyzerTestCase { + @NonNls private static final String BASE_PATH = "/codeInsight/daemonCodeAnalyzer/genericsHighlightingGenerated8"; + + @Override + protected Sdk getProjectJDK() { + return IdeaTestUtil.getMockJdk18(); + } + + public void testEmptyTestT() throws Exception {} + + @Bombed(day = 30, month = Calendar.JANUARY, year = 2015) + public void testUnrelatedClasses() throws Exception { + doTest(); + } + + private void doTest() { + LanguageLevelProjectExtension.getInstance(getJavaFacade().getProject()).setLanguageLevel(LanguageLevel.JDK_1_8); + IdeaTestUtil.setTestVersion(JavaSdkVersion.JDK_1_8, getModule(), myTestRootDisposable); + doTest(BASE_PATH + "/" + getTestName(false) + ".java", false, false); + } +}