[{"data":1,"prerenderedAt":5218},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet08-j":28,"surround-\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet08-j":3640,"sidebar-sei-cert-oracle-coding-standard-for-java":3647},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":27,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":25,"path":26},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":29,"title":30,"body":31,"description":3627,"extension":3628,"meta":3629,"navigation":7,"path":3636,"seo":3637,"stem":3638,"__hash__":3639},"content\u002F6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F10.met08-j.md","MET08-J. Preserve the equality contract when overriding the equals() method",{"type":32,"value":33,"toc":3606},"minimark",[34,38,61,92,98,119,125,202,207,212,239,643,673,677,686,930,934,944,1522,1558,1562,1594,1607,2001,2005,2011,2185,2189,2206,2215,2225,2234,2252,2263,2396,2400,2406,2534,2545,2553,2599,2610,2622,2749,2766,2773,2790,2796,2866,2871,2888,3104,3108,3138,3142,3148,3214,3219,3350,3354,3383,3387,3578,3581,3602],[35,36,30],"h1",{"id":37},"met08-j-preserve-the-equality-contract-when-overriding-the-equals-method",[39,40,41,42,46,47,49,50,54,55,60],"p",{},"Composition or inheritance may be used to create a new class that both encapsulates an existing class and adds one or more fields. When one class extends another in this way, the concept of equality for the subclass may or may not involve its new fields. That is, when comparing two subclass objects for equality, sometimes their respective fields must also be equal, and other times they need not be equal. Depending on the concept of equality for the subclass, the subclass might override ",[43,44,45],"code",{},"equals()"," . Furthermore, this method must follow the general contract for ",[43,48,45],{}," , as specified by ",[51,52,53],"em",{},"The Java Language Specification"," (JLS) [ ",[56,57,59],"a",{"href":58},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-JLS15","JLS 2015"," ].",[39,62,63,64,67,68,70,71,74,75,77,78,80,81,84,85,88,89,91],{},"An object is characterized both by its identity (location in memory) and by its state (actual data). The ",[43,65,66],{},"=="," operator compares only the identities of two objects (to check whether the references refer to the same object); the ",[43,69,45],{}," method defined in ",[43,72,73],{},"java.lang.Object"," can be overridden to compare the state as well. When a class defines an ",[43,76,45],{}," method, it implies that the method compares state. When the class lacks a customized ",[43,79,45],{}," method (either locally declared or inherited from a parent class), it uses the default ",[43,82,83],{},"Object.equals()"," implementation inherited from ",[43,86,87],{},"Object"," . The default ",[43,90,83],{}," implementation compares only the references and may produce unexpected results.",[39,93,94,95,97],{},"The ",[43,96,45],{}," method applies only to objects, not to primitives.",[39,99,100,101,103,104,106,107,109,110,112,113,115,116,118],{},"Enumerated types have a fixed set of distinct values that may be compared using ",[43,102,66],{}," rather than the ",[43,105,45],{}," method. Note that enumerated types provide an ",[43,108,45],{}," implementation that uses ",[43,111,66],{}," internally; this default cannot be overridden. More generally, subclasses that both inherit an implementation of ",[43,114,45],{}," from a superclass and lack a requirement for additional functionality need not override the ",[43,117,45],{}," method.",[39,120,121,122,124],{},"The general usage contract for ",[43,123,45],{}," , as specified by the JLS, establishes five requirements:",[126,127,128,140,157,179,193],"ol",{},[129,130,131,132,135,136,139],"li",{},"It is reflexive: For any reference value ",[43,133,134],{},"x"," , ",[43,137,138],{},"x.equals(x)"," must return true.",[129,141,142,143,145,146,135,149,152,153,156],{},"It is symmetric: For any reference values ",[43,144,134],{}," and ",[43,147,148],{},"y",[43,150,151],{},"x.equals(y)"," must return true if and only if ",[43,154,155],{},"y.equals(x)"," returns true.",[129,158,159,160,135,162,164,165,168,169,171,172,175,176,139],{},"It is transitive: For any reference values ",[43,161,134],{},[43,163,148],{}," , and ",[43,166,167],{},"z"," , if ",[43,170,151],{}," returns true and ",[43,173,174],{},"y.equals(z)"," returns true, then ",[43,177,178],{},"x.equals(z)",[129,180,181,182,145,184,186,187,189,190,192],{},"It is consistent: For any reference values ",[43,183,134],{},[43,185,148],{}," , multiple invocations of ",[43,188,151],{}," consistently return true or consistently return false, provided no information used in ",[43,191,45],{}," comparisons on the object is modified.",[129,194,195,196,135,198,201],{},"For any non-null reference value ",[43,197,134],{},[43,199,200],{},"x.equals(null)"," must return false.",[39,203,204,205,118],{},"Never violate any of these requirements when overriding the ",[43,206,45],{},[208,209,211],"h2",{"id":210},"noncompliant-code-example-symmetry","Noncompliant Code Example (Symmetry)",[39,213,214,215,218,219,222,223,225,226,228,229,231,232,235,236,238],{},"This noncompliant code example defines a ",[43,216,217],{},"CaseInsensitiveString"," class that includes a ",[43,220,221],{},"String"," and overrides the ",[43,224,45],{}," method. The ",[43,227,217],{}," class knows about ordinary strings, but the ",[43,230,221],{}," class has no knowledge of case-insensitive strings. Consequently, the ",[43,233,234],{},"CaseInsensitiveString.equals()"," method should not attempt to interoperate with objects of the ",[43,237,221],{}," class.",[240,241,243],"code-block",{"quality":242},"bad",[244,245,250],"pre",{"className":246,"code":247,"language":248,"meta":249,"style":249},"language-java shiki shiki-themes github-light github-dark monokai","public final class CaseInsensitiveString {\n private String s;\n\n public CaseInsensitiveString(String s) {\n if (s == null) {\n throw new NullPointerException();\n }\n this.s = s;\n }\n\n \u002F\u002F This method violates symmetry\n public boolean equals(Object o) {\n if (o instanceof CaseInsensitiveString) {\n return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);\n }\n\n if (o instanceof String) {\n return s.equalsIgnoreCase((String)o);\n }\n return false;\n }\n\n \u002F\u002F Comply with MET09-J\n public int hashCode() {\u002F* ... *\u002F}\n\n public static void main(String[] args) {\n CaseInsensitiveString cis = new CaseInsensitiveString(\"Java\");\n String s = \"java\";\n System.out.println(cis.equals(s)); \u002F\u002F Returns true\n System.out.println(s.equals(cis)); \u002F\u002F Returns false\n }\n}\n","java","",[43,251,252,275,288,294,315,332,347,353,368,374,379,386,407,421,436,441,446,458,470,475,487,492,497,503,523,528,554,578,594,615,633,638],{"__ignoreMap":249},[253,254,257,261,264,267,271],"span",{"class":255,"line":256},"line",1,[253,258,260],{"class":259},"sC2Qs","public",[253,262,263],{"class":259}," final",[253,265,266],{"class":259}," class",[253,268,270],{"class":269},"sz2Vg"," CaseInsensitiveString",[253,272,274],{"class":273},"sMOD_"," {\n",[253,276,278,281,285],{"class":255,"line":277},2,[253,279,280],{"class":259}," private",[253,282,284],{"class":283},"sk8M1"," String",[253,286,287],{"class":273}," s;\n",[253,289,291],{"class":255,"line":290},3,[253,292,293],{"emptyLinePlaceholder":7},"\n",[253,295,297,300,303,306,308,312],{"class":255,"line":296},4,[253,298,299],{"class":259}," public",[253,301,270],{"class":302},"srTi1",[253,304,305],{"class":273},"(",[253,307,221],{"class":283},[253,309,311],{"class":310},"sTHNf"," s",[253,313,314],{"class":273},") {\n",[253,316,318,321,324,326,330],{"class":255,"line":317},5,[253,319,320],{"class":259}," if",[253,322,323],{"class":273}," (s ",[253,325,66],{"class":259},[253,327,329],{"class":328},"s7F3e"," null",[253,331,314],{"class":273},[253,333,335,338,341,344],{"class":255,"line":334},6,[253,336,337],{"class":259}," throw",[253,339,340],{"class":259}," new",[253,342,343],{"class":302}," NullPointerException",[253,345,346],{"class":273},"();\n",[253,348,350],{"class":255,"line":349},7,[253,351,352],{"class":273}," }\n",[253,354,356,360,363,366],{"class":255,"line":355},8,[253,357,359],{"class":358},"sP7S_"," this",[253,361,362],{"class":273},".s ",[253,364,365],{"class":259},"=",[253,367,287],{"class":273},[253,369,371],{"class":255,"line":370},9,[253,372,373],{"class":273}," }\n",[253,375,377],{"class":255,"line":376},10,[253,378,293],{"emptyLinePlaceholder":7},[253,380,382],{"class":255,"line":381},11,[253,383,385],{"class":384},"s8-w5"," \u002F\u002F This method violates symmetry\n",[253,387,389,391,395,398,400,402,405],{"class":255,"line":388},12,[253,390,299],{"class":259},[253,392,394],{"class":393},"sq6CD"," boolean",[253,396,397],{"class":302}," equals",[253,399,305],{"class":273},[253,401,87],{"class":283},[253,403,404],{"class":310}," o",[253,406,314],{"class":273},[253,408,410,412,415,418],{"class":255,"line":409},13,[253,411,320],{"class":259},[253,413,414],{"class":273}," (o ",[253,416,417],{"class":259},"instanceof",[253,419,420],{"class":273}," CaseInsensitiveString) {\n",[253,422,424,427,430,433],{"class":255,"line":423},14,[253,425,426],{"class":259}," return",[253,428,429],{"class":273}," s.",[253,431,432],{"class":302},"equalsIgnoreCase",[253,434,435],{"class":273},"(((CaseInsensitiveString)o).s);\n",[253,437,439],{"class":255,"line":438},15,[253,440,352],{"class":273},[253,442,444],{"class":255,"line":443},16,[253,445,293],{"emptyLinePlaceholder":7},[253,447,449,451,453,455],{"class":255,"line":448},17,[253,450,320],{"class":259},[253,452,414],{"class":273},[253,454,417],{"class":259},[253,456,457],{"class":273}," String) {\n",[253,459,461,463,465,467],{"class":255,"line":460},18,[253,462,426],{"class":259},[253,464,429],{"class":273},[253,466,432],{"class":302},[253,468,469],{"class":273},"((String)o);\n",[253,471,473],{"class":255,"line":472},19,[253,474,352],{"class":273},[253,476,478,481,484],{"class":255,"line":477},20,[253,479,480],{"class":259}," return",[253,482,483],{"class":328}," false",[253,485,486],{"class":273},";\n",[253,488,490],{"class":255,"line":489},21,[253,491,373],{"class":273},[253,493,495],{"class":255,"line":494},22,[253,496,293],{"emptyLinePlaceholder":7},[253,498,500],{"class":255,"line":499},23,[253,501,502],{"class":384}," \u002F\u002F Comply with MET09-J\n",[253,504,506,508,511,514,517,520],{"class":255,"line":505},24,[253,507,299],{"class":259},[253,509,510],{"class":393}," int",[253,512,513],{"class":302}," hashCode",[253,515,516],{"class":273},"() {",[253,518,519],{"class":384},"\u002F* ... *\u002F",[253,521,522],{"class":273},"}\n",[253,524,526],{"class":255,"line":525},25,[253,527,293],{"emptyLinePlaceholder":7},[253,529,531,533,536,539,542,544,546,549,552],{"class":255,"line":530},26,[253,532,299],{"class":259},[253,534,535],{"class":259}," static",[253,537,538],{"class":393}," void",[253,540,541],{"class":302}," main",[253,543,305],{"class":273},[253,545,221],{"class":393},[253,547,548],{"class":273},"[] ",[253,550,551],{"class":310},"args",[253,553,314],{"class":273},[253,555,557,560,563,565,567,569,571,575],{"class":255,"line":556},27,[253,558,559],{"class":283}," CaseInsensitiveString",[253,561,562],{"class":273}," cis ",[253,564,365],{"class":259},[253,566,340],{"class":259},[253,568,270],{"class":302},[253,570,305],{"class":273},[253,572,574],{"class":573},"sstjo","\"Java\"",[253,576,577],{"class":273},");\n",[253,579,581,584,587,589,592],{"class":255,"line":580},28,[253,582,583],{"class":283}," String",[253,585,586],{"class":273}," s ",[253,588,365],{"class":259},[253,590,591],{"class":573}," \"java\"",[253,593,486],{"class":273},[253,595,597,600,603,606,609,612],{"class":255,"line":596},29,[253,598,599],{"class":273}," System.out.",[253,601,602],{"class":302},"println",[253,604,605],{"class":273},"(cis.",[253,607,608],{"class":302},"equals",[253,610,611],{"class":273},"(s)); ",[253,613,614],{"class":384},"\u002F\u002F Returns true\n",[253,616,618,620,622,625,627,630],{"class":255,"line":617},30,[253,619,599],{"class":273},[253,621,602],{"class":302},[253,623,624],{"class":273},"(s.",[253,626,608],{"class":302},[253,628,629],{"class":273},"(cis)); ",[253,631,632],{"class":384},"\u002F\u002F Returns false\n",[253,634,636],{"class":255,"line":635},31,[253,637,373],{"class":273},[253,639,641],{"class":255,"line":640},32,[253,642,522],{"class":273},[39,644,645,646,648,649,651,652,654,655,658,659,654,661,664,665,668,669,672],{},"By operating on ",[43,647,221],{}," objects, the ",[43,650,234],{}," method violates the second contract requirement (symmetry). Because of the asymmetry, given a ",[43,653,221],{}," object ",[43,656,657],{},"s"," and a ",[43,660,217],{},[43,662,663],{},"cis"," that differ only in case, ",[43,666,667],{},"cis.equals(s))"," returns true, while ",[43,670,671],{},"s.equals(cis)"," returns false.",[208,674,676],{"id":675},"compliant-solution","Compliant Solution",[39,678,679,680,682,683,685],{},"In this compliant solution, the ",[43,681,234],{}," method is simplified to operate only on instances of the ",[43,684,217],{}," class, consequently preserving symmetry:",[240,687,689],{"quality":688},"good",[244,690,692],{"className":246,"code":691,"language":248,"meta":249,"style":249},"public final class CaseInsensitiveString {\n private String s;\n\n public CaseInsensitiveString(String s) {\n if (s == null) {\n throw new NullPointerException();\n }\n this.s = s;\n }\n\n public boolean equals(Object o) {\n return o instanceof CaseInsensitiveString &&\n ((CaseInsensitiveString)o).s.equalsIgnoreCase(s);\n }\n\n public int hashCode() {\u002F* ... *\u002F}\n\n public static void main(String[] args) {\n CaseInsensitiveString cis = new CaseInsensitiveString(\"Java\");\n String s = \"java\";\n System.out.println(cis.equals(s)); \u002F\u002F Returns false now\n System.out.println(s.equals(cis)); \u002F\u002F Returns false now\n }\n}\n",[43,693,694,706,714,718,732,744,754,758,768,772,776,792,807,817,821,825,839,843,863,881,893,908,922,926],{"__ignoreMap":249},[253,695,696,698,700,702,704],{"class":255,"line":256},[253,697,260],{"class":259},[253,699,263],{"class":259},[253,701,266],{"class":259},[253,703,270],{"class":269},[253,705,274],{"class":273},[253,707,708,710,712],{"class":255,"line":277},[253,709,280],{"class":259},[253,711,284],{"class":283},[253,713,287],{"class":273},[253,715,716],{"class":255,"line":290},[253,717,293],{"emptyLinePlaceholder":7},[253,719,720,722,724,726,728,730],{"class":255,"line":296},[253,721,299],{"class":259},[253,723,270],{"class":302},[253,725,305],{"class":273},[253,727,221],{"class":283},[253,729,311],{"class":310},[253,731,314],{"class":273},[253,733,734,736,738,740,742],{"class":255,"line":317},[253,735,320],{"class":259},[253,737,323],{"class":273},[253,739,66],{"class":259},[253,741,329],{"class":328},[253,743,314],{"class":273},[253,745,746,748,750,752],{"class":255,"line":334},[253,747,337],{"class":259},[253,749,340],{"class":259},[253,751,343],{"class":302},[253,753,346],{"class":273},[253,755,756],{"class":255,"line":349},[253,757,352],{"class":273},[253,759,760,762,764,766],{"class":255,"line":355},[253,761,359],{"class":358},[253,763,362],{"class":273},[253,765,365],{"class":259},[253,767,287],{"class":273},[253,769,770],{"class":255,"line":370},[253,771,373],{"class":273},[253,773,774],{"class":255,"line":376},[253,775,293],{"emptyLinePlaceholder":7},[253,777,778,780,782,784,786,788,790],{"class":255,"line":381},[253,779,299],{"class":259},[253,781,394],{"class":393},[253,783,397],{"class":302},[253,785,305],{"class":273},[253,787,87],{"class":283},[253,789,404],{"class":310},[253,791,314],{"class":273},[253,793,794,796,799,801,804],{"class":255,"line":388},[253,795,480],{"class":259},[253,797,798],{"class":273}," o ",[253,800,417],{"class":259},[253,802,803],{"class":273}," CaseInsensitiveString ",[253,805,806],{"class":259},"&&\n",[253,808,809,812,814],{"class":255,"line":409},[253,810,811],{"class":273}," ((CaseInsensitiveString)o).s.",[253,813,432],{"class":302},[253,815,816],{"class":273},"(s);\n",[253,818,819],{"class":255,"line":423},[253,820,373],{"class":273},[253,822,823],{"class":255,"line":438},[253,824,293],{"emptyLinePlaceholder":7},[253,826,827,829,831,833,835,837],{"class":255,"line":443},[253,828,299],{"class":259},[253,830,510],{"class":393},[253,832,513],{"class":302},[253,834,516],{"class":273},[253,836,519],{"class":384},[253,838,522],{"class":273},[253,840,841],{"class":255,"line":448},[253,842,293],{"emptyLinePlaceholder":7},[253,844,845,847,849,851,853,855,857,859,861],{"class":255,"line":460},[253,846,299],{"class":259},[253,848,535],{"class":259},[253,850,538],{"class":393},[253,852,541],{"class":302},[253,854,305],{"class":273},[253,856,221],{"class":393},[253,858,548],{"class":273},[253,860,551],{"class":310},[253,862,314],{"class":273},[253,864,865,867,869,871,873,875,877,879],{"class":255,"line":472},[253,866,559],{"class":283},[253,868,562],{"class":273},[253,870,365],{"class":259},[253,872,340],{"class":259},[253,874,270],{"class":302},[253,876,305],{"class":273},[253,878,574],{"class":573},[253,880,577],{"class":273},[253,882,883,885,887,889,891],{"class":255,"line":477},[253,884,583],{"class":283},[253,886,586],{"class":273},[253,888,365],{"class":259},[253,890,591],{"class":573},[253,892,486],{"class":273},[253,894,895,897,899,901,903,905],{"class":255,"line":489},[253,896,599],{"class":273},[253,898,602],{"class":302},[253,900,605],{"class":273},[253,902,608],{"class":302},[253,904,611],{"class":273},[253,906,907],{"class":384},"\u002F\u002F Returns false now\n",[253,909,910,912,914,916,918,920],{"class":255,"line":494},[253,911,599],{"class":273},[253,913,602],{"class":302},[253,915,624],{"class":273},[253,917,608],{"class":302},[253,919,629],{"class":273},[253,921,907],{"class":384},[253,923,924],{"class":255,"line":499},[253,925,373],{"class":273},[253,927,928],{"class":255,"line":505},[253,929,522],{"class":273},[208,931,933],{"id":932},"noncompliant-code-example-transitivity","Noncompliant Code Example (Transitivity)",[39,935,936,937,940,941,238],{},"This noncompliant code example defines an ",[43,938,939],{},"XCard"," class that extends the ",[43,942,943],{},"Card",[240,945,946],{"quality":242},[244,947,949],{"className":246,"code":948,"language":248,"meta":249,"style":249},"public class Card {\n private final int number;\n\n public Card(int number) {\n this.number = number;\n }\n\n public boolean equals(Object o) {\n if (!(o instanceof Card)) {\n return false;\n }\n\n Card c = (Card)o;\n return c.number == number;\n }\n\n public int hashCode() {\u002F* ... *\u002F}\n\n}\n\nclass XCard extends Card {\n private String type;\n public XCard(int number, String type) {\n super(number);\n this.type = type;\n }\n\n public boolean equals(Object o) {\n if (!(o instanceof Card)) {\n return false;\n }\n\n \u002F\u002F Normal Card, do not compare type\n if (!(o instanceof XCard)) {\n return o.equals(this);\n }\n\n \u002F\u002F It is an XCard, compare type as well\n XCard xc = (XCard)o;\n return super.equals(o) && xc.type == type;\n }\n\n public int hashCode() {\u002F* ... *\u002F}\n\n public static void main(String[] args) {\n XCard p1 = new XCard(1, \"type1\");\n Card p2 = new Card(1);\n XCard p3 = new XCard(1, \"type2\");\n System.out.println(p1.equals(p2)); \u002F\u002F Returns true\n System.out.println(p2.equals(p3)); \u002F\u002F Returns true\n System.out.println(p1.equals(p3)); \u002F\u002F Returns false\n \u002F\u002F violating transitivity\n }\n}\n",[43,950,951,962,973,977,993,1004,1008,1012,1028,1046,1054,1058,1062,1075,1086,1090,1094,1108,1112,1116,1120,1136,1145,1167,1175,1186,1190,1194,1210,1224,1232,1236,1240,1246,1262,1279,1284,1289,1295,1309,1335,1340,1345,1360,1365,1386,1412,1432,1457,1474,1491,1506,1512,1517],{"__ignoreMap":249},[253,952,953,955,957,960],{"class":255,"line":256},[253,954,260],{"class":259},[253,956,266],{"class":259},[253,958,959],{"class":269}," Card",[253,961,274],{"class":273},[253,963,964,966,968,970],{"class":255,"line":277},[253,965,280],{"class":259},[253,967,263],{"class":259},[253,969,510],{"class":393},[253,971,972],{"class":273}," number;\n",[253,974,975],{"class":255,"line":290},[253,976,293],{"emptyLinePlaceholder":7},[253,978,979,981,983,985,988,991],{"class":255,"line":296},[253,980,299],{"class":259},[253,982,959],{"class":302},[253,984,305],{"class":273},[253,986,987],{"class":393},"int",[253,989,990],{"class":310}," number",[253,992,314],{"class":273},[253,994,995,997,1000,1002],{"class":255,"line":317},[253,996,359],{"class":358},[253,998,999],{"class":273},".number ",[253,1001,365],{"class":259},[253,1003,972],{"class":273},[253,1005,1006],{"class":255,"line":334},[253,1007,373],{"class":273},[253,1009,1010],{"class":255,"line":349},[253,1011,293],{"emptyLinePlaceholder":7},[253,1013,1014,1016,1018,1020,1022,1024,1026],{"class":255,"line":355},[253,1015,299],{"class":259},[253,1017,394],{"class":393},[253,1019,397],{"class":302},[253,1021,305],{"class":273},[253,1023,87],{"class":283},[253,1025,404],{"class":310},[253,1027,314],{"class":273},[253,1029,1030,1032,1035,1038,1041,1043],{"class":255,"line":370},[253,1031,320],{"class":259},[253,1033,1034],{"class":273}," (",[253,1036,1037],{"class":259},"!",[253,1039,1040],{"class":273},"(o ",[253,1042,417],{"class":259},[253,1044,1045],{"class":273}," Card)) {\n",[253,1047,1048,1050,1052],{"class":255,"line":376},[253,1049,426],{"class":259},[253,1051,483],{"class":328},[253,1053,486],{"class":273},[253,1055,1056],{"class":255,"line":381},[253,1057,352],{"class":273},[253,1059,1060],{"class":255,"line":388},[253,1061,293],{"emptyLinePlaceholder":7},[253,1063,1064,1067,1070,1072],{"class":255,"line":409},[253,1065,1066],{"class":283}," Card",[253,1068,1069],{"class":273}," c ",[253,1071,365],{"class":259},[253,1073,1074],{"class":273}," (Card)o;\n",[253,1076,1077,1079,1082,1084],{"class":255,"line":423},[253,1078,480],{"class":259},[253,1080,1081],{"class":273}," c.number ",[253,1083,66],{"class":259},[253,1085,972],{"class":273},[253,1087,1088],{"class":255,"line":438},[253,1089,373],{"class":273},[253,1091,1092],{"class":255,"line":443},[253,1093,293],{"emptyLinePlaceholder":7},[253,1095,1096,1098,1100,1102,1104,1106],{"class":255,"line":448},[253,1097,299],{"class":259},[253,1099,510],{"class":393},[253,1101,513],{"class":302},[253,1103,516],{"class":273},[253,1105,519],{"class":384},[253,1107,522],{"class":273},[253,1109,1110],{"class":255,"line":460},[253,1111,293],{"emptyLinePlaceholder":7},[253,1113,1114],{"class":255,"line":472},[253,1115,522],{"class":273},[253,1117,1118],{"class":255,"line":477},[253,1119,293],{"emptyLinePlaceholder":7},[253,1121,1122,1125,1128,1131,1134],{"class":255,"line":489},[253,1123,1124],{"class":259},"class",[253,1126,1127],{"class":269}," XCard",[253,1129,1130],{"class":259}," extends",[253,1132,959],{"class":1133},"s30JN",[253,1135,274],{"class":273},[253,1137,1138,1140,1142],{"class":255,"line":494},[253,1139,280],{"class":259},[253,1141,284],{"class":283},[253,1143,1144],{"class":273}," type;\n",[253,1146,1147,1149,1151,1153,1155,1157,1160,1162,1165],{"class":255,"line":499},[253,1148,299],{"class":259},[253,1150,1127],{"class":302},[253,1152,305],{"class":273},[253,1154,987],{"class":393},[253,1156,990],{"class":310},[253,1158,1159],{"class":273},", ",[253,1161,221],{"class":283},[253,1163,1164],{"class":310}," type",[253,1166,314],{"class":273},[253,1168,1169,1172],{"class":255,"line":505},[253,1170,1171],{"class":358}," super",[253,1173,1174],{"class":273},"(number);\n",[253,1176,1177,1179,1182,1184],{"class":255,"line":525},[253,1178,359],{"class":358},[253,1180,1181],{"class":273},".type ",[253,1183,365],{"class":259},[253,1185,1144],{"class":273},[253,1187,1188],{"class":255,"line":530},[253,1189,373],{"class":273},[253,1191,1192],{"class":255,"line":556},[253,1193,293],{"emptyLinePlaceholder":7},[253,1195,1196,1198,1200,1202,1204,1206,1208],{"class":255,"line":580},[253,1197,299],{"class":259},[253,1199,394],{"class":393},[253,1201,397],{"class":302},[253,1203,305],{"class":273},[253,1205,87],{"class":283},[253,1207,404],{"class":310},[253,1209,314],{"class":273},[253,1211,1212,1214,1216,1218,1220,1222],{"class":255,"line":596},[253,1213,320],{"class":259},[253,1215,1034],{"class":273},[253,1217,1037],{"class":259},[253,1219,1040],{"class":273},[253,1221,417],{"class":259},[253,1223,1045],{"class":273},[253,1225,1226,1228,1230],{"class":255,"line":617},[253,1227,426],{"class":259},[253,1229,483],{"class":328},[253,1231,486],{"class":273},[253,1233,1234],{"class":255,"line":635},[253,1235,352],{"class":273},[253,1237,1238],{"class":255,"line":640},[253,1239,293],{"emptyLinePlaceholder":7},[253,1241,1243],{"class":255,"line":1242},33,[253,1244,1245],{"class":384}," \u002F\u002F Normal Card, do not compare type\n",[253,1247,1249,1251,1253,1255,1257,1259],{"class":255,"line":1248},34,[253,1250,320],{"class":259},[253,1252,1034],{"class":273},[253,1254,1037],{"class":259},[253,1256,1040],{"class":273},[253,1258,417],{"class":259},[253,1260,1261],{"class":273}," XCard)) {\n",[253,1263,1265,1267,1270,1272,1274,1277],{"class":255,"line":1264},35,[253,1266,426],{"class":259},[253,1268,1269],{"class":273}," o.",[253,1271,608],{"class":302},[253,1273,305],{"class":273},[253,1275,1276],{"class":358},"this",[253,1278,577],{"class":273},[253,1280,1282],{"class":255,"line":1281},36,[253,1283,352],{"class":273},[253,1285,1287],{"class":255,"line":1286},37,[253,1288,293],{"emptyLinePlaceholder":7},[253,1290,1292],{"class":255,"line":1291},38,[253,1293,1294],{"class":384}," \u002F\u002F It is an XCard, compare type as well\n",[253,1296,1298,1301,1304,1306],{"class":255,"line":1297},39,[253,1299,1300],{"class":283}," XCard",[253,1302,1303],{"class":273}," xc ",[253,1305,365],{"class":259},[253,1307,1308],{"class":273}," (XCard)o;\n",[253,1310,1312,1314,1317,1320,1322,1325,1328,1331,1333],{"class":255,"line":1311},40,[253,1313,480],{"class":259},[253,1315,1316],{"class":358}," super",[253,1318,1319],{"class":273},".",[253,1321,608],{"class":302},[253,1323,1324],{"class":273},"(o) ",[253,1326,1327],{"class":259},"&&",[253,1329,1330],{"class":273}," xc.type ",[253,1332,66],{"class":259},[253,1334,1144],{"class":273},[253,1336,1338],{"class":255,"line":1337},41,[253,1339,373],{"class":273},[253,1341,1343],{"class":255,"line":1342},42,[253,1344,293],{"emptyLinePlaceholder":7},[253,1346,1348,1350,1352,1354,1356,1358],{"class":255,"line":1347},43,[253,1349,299],{"class":259},[253,1351,510],{"class":393},[253,1353,513],{"class":302},[253,1355,516],{"class":273},[253,1357,519],{"class":384},[253,1359,522],{"class":273},[253,1361,1363],{"class":255,"line":1362},44,[253,1364,293],{"emptyLinePlaceholder":7},[253,1366,1368,1370,1372,1374,1376,1378,1380,1382,1384],{"class":255,"line":1367},45,[253,1369,299],{"class":259},[253,1371,535],{"class":259},[253,1373,538],{"class":393},[253,1375,541],{"class":302},[253,1377,305],{"class":273},[253,1379,221],{"class":393},[253,1381,548],{"class":273},[253,1383,551],{"class":310},[253,1385,314],{"class":273},[253,1387,1389,1391,1394,1396,1398,1400,1402,1405,1407,1410],{"class":255,"line":1388},46,[253,1390,1300],{"class":283},[253,1392,1393],{"class":273}," p1 ",[253,1395,365],{"class":259},[253,1397,340],{"class":259},[253,1399,1127],{"class":302},[253,1401,305],{"class":273},[253,1403,1404],{"class":328},"1",[253,1406,1159],{"class":273},[253,1408,1409],{"class":573},"\"type1\"",[253,1411,577],{"class":273},[253,1413,1415,1417,1420,1422,1424,1426,1428,1430],{"class":255,"line":1414},47,[253,1416,1066],{"class":283},[253,1418,1419],{"class":273}," p2 ",[253,1421,365],{"class":259},[253,1423,340],{"class":259},[253,1425,959],{"class":302},[253,1427,305],{"class":273},[253,1429,1404],{"class":328},[253,1431,577],{"class":273},[253,1433,1435,1437,1440,1442,1444,1446,1448,1450,1452,1455],{"class":255,"line":1434},48,[253,1436,1300],{"class":283},[253,1438,1439],{"class":273}," p3 ",[253,1441,365],{"class":259},[253,1443,340],{"class":259},[253,1445,1127],{"class":302},[253,1447,305],{"class":273},[253,1449,1404],{"class":328},[253,1451,1159],{"class":273},[253,1453,1454],{"class":573},"\"type2\"",[253,1456,577],{"class":273},[253,1458,1460,1462,1464,1467,1469,1472],{"class":255,"line":1459},49,[253,1461,599],{"class":273},[253,1463,602],{"class":302},[253,1465,1466],{"class":273},"(p1.",[253,1468,608],{"class":302},[253,1470,1471],{"class":273},"(p2)); ",[253,1473,614],{"class":384},[253,1475,1477,1479,1481,1484,1486,1489],{"class":255,"line":1476},50,[253,1478,599],{"class":273},[253,1480,602],{"class":302},[253,1482,1483],{"class":273},"(p2.",[253,1485,608],{"class":302},[253,1487,1488],{"class":273},"(p3)); ",[253,1490,614],{"class":384},[253,1492,1494,1496,1498,1500,1502,1504],{"class":255,"line":1493},51,[253,1495,599],{"class":273},[253,1497,602],{"class":302},[253,1499,1466],{"class":273},[253,1501,608],{"class":302},[253,1503,1488],{"class":273},[253,1505,632],{"class":384},[253,1507,1509],{"class":255,"line":1508},52,[253,1510,1511],{"class":384}," \u002F\u002F violating transitivity\n",[253,1513,1515],{"class":255,"line":1514},53,[253,1516,373],{"class":273},[253,1518,1520],{"class":255,"line":1519},54,[253,1521,522],{"class":273},[39,1523,1524,1525,145,1528,1531,1532,145,1534,1537,1538,145,1540,1542,1543,1545,1546,1548,1549,145,1551,1553,1554,1557],{},"In the noncompliant code example, ",[43,1526,1527],{},"p1",[43,1529,1530],{},"p2"," compare equal and ",[43,1533,1530],{},[43,1535,1536],{},"p3"," compare equal, but ",[43,1539,1527],{},[43,1541,1536],{}," compare unequal, violating the transitivity requirement. The problem is that the ",[43,1544,943],{}," class has no knowledge of the ",[43,1547,939],{}," class and consequently cannot determine that ",[43,1550,1530],{},[43,1552,1536],{}," have different values for the field ",[43,1555,1556],{},"type"," .",[208,1559,1561],{"id":1560},"compliant-solution-delegation","Compliant Solution (Delegation)",[39,1563,1564,1565,1567,1568,1570,1571,1575,1576,1582,1583,1585,1586,1588,1589,1593],{},"Unfortunately, in this case it is impossible to extend the ",[43,1566,943],{}," class by adding a value or field in the subclass while preserving the Java ",[43,1569,45],{}," contract. This problem is not specific to the Card class but applies to any class hierarchy that can consider equal instances of distinct subclasses of some superclass. For such cases, use composition rather than inheritance to achieve the desired effect [ ",[56,1572,1574],{"href":1573},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Bloch08","Bloch 2008"," ], [Liskov 1994], [ ",[56,1577,1581],{"href":1578,"rel":1579},"https:\u002F\u002Fisocpp.org\u002Fwiki\u002Ffaq\u002Fproper-inheritance",[1580],"nofollow","Cline, C++ Super-FAQ"," ]. It is fundamentally impossible to have a class that both allows arbitrary subclass extensions and permits an ",[43,1584,45],{}," method that is reflexive, symmetric, and transitive, as is required by ",[43,1587,83],{}," . In the interests of consistency and security, we forgo arbitrary subclass extensions, and assume that ",[1590,1591],"binding",{"value":1592},"Card.equals()"," may impose certain restrictions on its subclasses.",[39,1595,1596,1597,1600,1601,1603,1604,118],{},"This compliant solution adopts this approach by adding a private ",[43,1598,1599],{},"card"," field to the ",[43,1602,939],{}," class and providing a public ",[43,1605,1606],{},"viewCard()",[240,1608,1609],{"quality":688},[244,1610,1612],{"className":246,"code":1611,"language":248,"meta":249,"style":249},"class XCard {\n private String type;\n private Card card; \u002F\u002F Composition\n\n public XCard(int number, String type) {\n card = new Card(number);\n this.type = type;\n }\n\n public Card viewCard() {\n return card;\n }\n\n public boolean equals(Object o) {\n if (!(o instanceof XCard)) {\n return false;\n }\n\n XCard cp = (XCard)o;\n return cp.card.equals(card) && cp.type.equals(type);\n }\n\n public int hashCode() {\u002F* ... *\u002F}\n\n public static void main(String[] args) {\n XCard p1 = new XCard(1, \"type1\");\n Card p2 = new Card(1);\n XCard p3 = new XCard(1, \"type2\");\n XCard p4 = new XCard(1, \"type1\");\n System.out.println(p1.equals(p2)); \u002F\u002F Prints false\n System.out.println(p2.equals(p3)); \u002F\u002F Prints false\n System.out.println(p1.equals(p3)); \u002F\u002F Prints false\n System.out.println(p1.equals(p4)); \u002F\u002F Prints true\n }\n}\n",[43,1613,1614,1622,1630,1642,1646,1666,1679,1689,1693,1697,1709,1716,1720,1724,1740,1754,1762,1766,1770,1781,1803,1807,1811,1825,1829,1849,1871,1889,1911,1934,1949,1963,1977,1993,1997],{"__ignoreMap":249},[253,1615,1616,1618,1620],{"class":255,"line":256},[253,1617,1124],{"class":259},[253,1619,1127],{"class":269},[253,1621,274],{"class":273},[253,1623,1624,1626,1628],{"class":255,"line":277},[253,1625,280],{"class":259},[253,1627,284],{"class":283},[253,1629,1144],{"class":273},[253,1631,1632,1634,1636,1639],{"class":255,"line":290},[253,1633,280],{"class":259},[253,1635,959],{"class":283},[253,1637,1638],{"class":273}," card; ",[253,1640,1641],{"class":384},"\u002F\u002F Composition\n",[253,1643,1644],{"class":255,"line":296},[253,1645,293],{"emptyLinePlaceholder":7},[253,1647,1648,1650,1652,1654,1656,1658,1660,1662,1664],{"class":255,"line":317},[253,1649,299],{"class":259},[253,1651,1127],{"class":302},[253,1653,305],{"class":273},[253,1655,987],{"class":393},[253,1657,990],{"class":310},[253,1659,1159],{"class":273},[253,1661,221],{"class":283},[253,1663,1164],{"class":310},[253,1665,314],{"class":273},[253,1667,1668,1671,1673,1675,1677],{"class":255,"line":334},[253,1669,1670],{"class":273}," card ",[253,1672,365],{"class":259},[253,1674,340],{"class":259},[253,1676,959],{"class":302},[253,1678,1174],{"class":273},[253,1680,1681,1683,1685,1687],{"class":255,"line":349},[253,1682,359],{"class":358},[253,1684,1181],{"class":273},[253,1686,365],{"class":259},[253,1688,1144],{"class":273},[253,1690,1691],{"class":255,"line":355},[253,1692,373],{"class":273},[253,1694,1695],{"class":255,"line":370},[253,1696,293],{"emptyLinePlaceholder":7},[253,1698,1699,1701,1703,1706],{"class":255,"line":376},[253,1700,299],{"class":259},[253,1702,959],{"class":283},[253,1704,1705],{"class":302}," viewCard",[253,1707,1708],{"class":273},"() {\n",[253,1710,1711,1713],{"class":255,"line":381},[253,1712,480],{"class":259},[253,1714,1715],{"class":273}," card;\n",[253,1717,1718],{"class":255,"line":388},[253,1719,373],{"class":273},[253,1721,1722],{"class":255,"line":409},[253,1723,293],{"emptyLinePlaceholder":7},[253,1725,1726,1728,1730,1732,1734,1736,1738],{"class":255,"line":423},[253,1727,299],{"class":259},[253,1729,394],{"class":393},[253,1731,397],{"class":302},[253,1733,305],{"class":273},[253,1735,87],{"class":283},[253,1737,404],{"class":310},[253,1739,314],{"class":273},[253,1741,1742,1744,1746,1748,1750,1752],{"class":255,"line":438},[253,1743,320],{"class":259},[253,1745,1034],{"class":273},[253,1747,1037],{"class":259},[253,1749,1040],{"class":273},[253,1751,417],{"class":259},[253,1753,1261],{"class":273},[253,1755,1756,1758,1760],{"class":255,"line":443},[253,1757,426],{"class":259},[253,1759,483],{"class":328},[253,1761,486],{"class":273},[253,1763,1764],{"class":255,"line":448},[253,1765,352],{"class":273},[253,1767,1768],{"class":255,"line":460},[253,1769,293],{"emptyLinePlaceholder":7},[253,1771,1772,1774,1777,1779],{"class":255,"line":472},[253,1773,1300],{"class":283},[253,1775,1776],{"class":273}," cp ",[253,1778,365],{"class":259},[253,1780,1308],{"class":273},[253,1782,1783,1785,1788,1790,1793,1795,1798,1800],{"class":255,"line":477},[253,1784,480],{"class":259},[253,1786,1787],{"class":273}," cp.card.",[253,1789,608],{"class":302},[253,1791,1792],{"class":273},"(card) ",[253,1794,1327],{"class":259},[253,1796,1797],{"class":273}," cp.type.",[253,1799,608],{"class":302},[253,1801,1802],{"class":273},"(type);\n",[253,1804,1805],{"class":255,"line":489},[253,1806,373],{"class":273},[253,1808,1809],{"class":255,"line":494},[253,1810,293],{"emptyLinePlaceholder":7},[253,1812,1813,1815,1817,1819,1821,1823],{"class":255,"line":499},[253,1814,299],{"class":259},[253,1816,510],{"class":393},[253,1818,513],{"class":302},[253,1820,516],{"class":273},[253,1822,519],{"class":384},[253,1824,522],{"class":273},[253,1826,1827],{"class":255,"line":505},[253,1828,293],{"emptyLinePlaceholder":7},[253,1830,1831,1833,1835,1837,1839,1841,1843,1845,1847],{"class":255,"line":525},[253,1832,299],{"class":259},[253,1834,535],{"class":259},[253,1836,538],{"class":393},[253,1838,541],{"class":302},[253,1840,305],{"class":273},[253,1842,221],{"class":393},[253,1844,548],{"class":273},[253,1846,551],{"class":310},[253,1848,314],{"class":273},[253,1850,1851,1853,1855,1857,1859,1861,1863,1865,1867,1869],{"class":255,"line":530},[253,1852,1300],{"class":283},[253,1854,1393],{"class":273},[253,1856,365],{"class":259},[253,1858,340],{"class":259},[253,1860,1127],{"class":302},[253,1862,305],{"class":273},[253,1864,1404],{"class":328},[253,1866,1159],{"class":273},[253,1868,1409],{"class":573},[253,1870,577],{"class":273},[253,1872,1873,1875,1877,1879,1881,1883,1885,1887],{"class":255,"line":556},[253,1874,1066],{"class":283},[253,1876,1419],{"class":273},[253,1878,365],{"class":259},[253,1880,340],{"class":259},[253,1882,959],{"class":302},[253,1884,305],{"class":273},[253,1886,1404],{"class":328},[253,1888,577],{"class":273},[253,1890,1891,1893,1895,1897,1899,1901,1903,1905,1907,1909],{"class":255,"line":580},[253,1892,1300],{"class":283},[253,1894,1439],{"class":273},[253,1896,365],{"class":259},[253,1898,340],{"class":259},[253,1900,1127],{"class":302},[253,1902,305],{"class":273},[253,1904,1404],{"class":328},[253,1906,1159],{"class":273},[253,1908,1454],{"class":573},[253,1910,577],{"class":273},[253,1912,1913,1915,1918,1920,1922,1924,1926,1928,1930,1932],{"class":255,"line":596},[253,1914,1300],{"class":283},[253,1916,1917],{"class":273}," p4 ",[253,1919,365],{"class":259},[253,1921,340],{"class":259},[253,1923,1127],{"class":302},[253,1925,305],{"class":273},[253,1927,1404],{"class":328},[253,1929,1159],{"class":273},[253,1931,1409],{"class":573},[253,1933,577],{"class":273},[253,1935,1936,1938,1940,1942,1944,1946],{"class":255,"line":617},[253,1937,599],{"class":273},[253,1939,602],{"class":302},[253,1941,1466],{"class":273},[253,1943,608],{"class":302},[253,1945,1471],{"class":273},[253,1947,1948],{"class":384},"\u002F\u002F Prints false\n",[253,1950,1951,1953,1955,1957,1959,1961],{"class":255,"line":635},[253,1952,599],{"class":273},[253,1954,602],{"class":302},[253,1956,1483],{"class":273},[253,1958,608],{"class":302},[253,1960,1488],{"class":273},[253,1962,1948],{"class":384},[253,1964,1965,1967,1969,1971,1973,1975],{"class":255,"line":640},[253,1966,599],{"class":273},[253,1968,602],{"class":302},[253,1970,1466],{"class":273},[253,1972,608],{"class":302},[253,1974,1488],{"class":273},[253,1976,1948],{"class":384},[253,1978,1979,1981,1983,1985,1987,1990],{"class":255,"line":1242},[253,1980,599],{"class":273},[253,1982,602],{"class":302},[253,1984,1466],{"class":273},[253,1986,608],{"class":302},[253,1988,1989],{"class":273},"(p4)); ",[253,1991,1992],{"class":384},"\u002F\u002F Prints true\n",[253,1994,1995],{"class":255,"line":1248},[253,1996,373],{"class":273},[253,1998,1999],{"class":255,"line":1264},[253,2000,522],{"class":273},[208,2002,2004],{"id":2003},"compliant-solution-class-comparison","Compliant Solution (Class Comparison)",[39,2006,2007,2008,2010],{},"If the ",[43,2009,1592],{}," method could unilaterally assume that two objects with distinct classes were not equal, it could be used in an inheritance hierarchy while preserving transitivity:",[240,2012,2013],{"quality":688},[244,2014,2016],{"className":246,"code":2015,"language":248,"meta":249,"style":249},"public class Card {\n private final int number;\n\n public Card(int number) {\n this.number = number;\n }\n\n public boolean equals(Object o) {\n if (!(o.getClass() == this.getClass())) {\n return false;\n }\n\n Card c = (Card)o;\n return c.number == number;\n }\n\n public int hashCode() {\u002F* ... *\u002F}\n\n}\n",[43,2017,2018,2028,2038,2042,2056,2066,2070,2074,2090,2119,2127,2131,2135,2145,2155,2159,2163,2177,2181],{"__ignoreMap":249},[253,2019,2020,2022,2024,2026],{"class":255,"line":256},[253,2021,260],{"class":259},[253,2023,266],{"class":259},[253,2025,959],{"class":269},[253,2027,274],{"class":273},[253,2029,2030,2032,2034,2036],{"class":255,"line":277},[253,2031,280],{"class":259},[253,2033,263],{"class":259},[253,2035,510],{"class":393},[253,2037,972],{"class":273},[253,2039,2040],{"class":255,"line":290},[253,2041,293],{"emptyLinePlaceholder":7},[253,2043,2044,2046,2048,2050,2052,2054],{"class":255,"line":296},[253,2045,299],{"class":259},[253,2047,959],{"class":302},[253,2049,305],{"class":273},[253,2051,987],{"class":393},[253,2053,990],{"class":310},[253,2055,314],{"class":273},[253,2057,2058,2060,2062,2064],{"class":255,"line":317},[253,2059,359],{"class":358},[253,2061,999],{"class":273},[253,2063,365],{"class":259},[253,2065,972],{"class":273},[253,2067,2068],{"class":255,"line":334},[253,2069,373],{"class":273},[253,2071,2072],{"class":255,"line":349},[253,2073,293],{"emptyLinePlaceholder":7},[253,2075,2076,2078,2080,2082,2084,2086,2088],{"class":255,"line":355},[253,2077,299],{"class":259},[253,2079,394],{"class":393},[253,2081,397],{"class":302},[253,2083,305],{"class":273},[253,2085,87],{"class":283},[253,2087,404],{"class":310},[253,2089,314],{"class":273},[253,2091,2092,2094,2096,2098,2101,2104,2107,2109,2112,2114,2116],{"class":255,"line":370},[253,2093,320],{"class":259},[253,2095,1034],{"class":273},[253,2097,1037],{"class":259},[253,2099,2100],{"class":273},"(o.",[253,2102,2103],{"class":302},"getClass",[253,2105,2106],{"class":273},"() ",[253,2108,66],{"class":259},[253,2110,2111],{"class":358}," this",[253,2113,1319],{"class":273},[253,2115,2103],{"class":302},[253,2117,2118],{"class":273},"())) {\n",[253,2120,2121,2123,2125],{"class":255,"line":376},[253,2122,426],{"class":259},[253,2124,483],{"class":328},[253,2126,486],{"class":273},[253,2128,2129],{"class":255,"line":381},[253,2130,352],{"class":273},[253,2132,2133],{"class":255,"line":388},[253,2134,293],{"emptyLinePlaceholder":7},[253,2136,2137,2139,2141,2143],{"class":255,"line":409},[253,2138,1066],{"class":283},[253,2140,1069],{"class":273},[253,2142,365],{"class":259},[253,2144,1074],{"class":273},[253,2146,2147,2149,2151,2153],{"class":255,"line":423},[253,2148,480],{"class":259},[253,2150,1081],{"class":273},[253,2152,66],{"class":259},[253,2154,972],{"class":273},[253,2156,2157],{"class":255,"line":438},[253,2158,373],{"class":273},[253,2160,2161],{"class":255,"line":443},[253,2162,293],{"emptyLinePlaceholder":7},[253,2164,2165,2167,2169,2171,2173,2175],{"class":255,"line":448},[253,2166,299],{"class":259},[253,2168,510],{"class":393},[253,2170,513],{"class":302},[253,2172,516],{"class":273},[253,2174,519],{"class":384},[253,2176,522],{"class":273},[253,2178,2179],{"class":255,"line":460},[253,2180,293],{"emptyLinePlaceholder":7},[253,2182,2183],{"class":255,"line":472},[253,2184,522],{"class":273},[208,2186,2188],{"id":2187},"noncompliant-code-example-consistency","Noncompliant Code Example (Consistency)",[39,2190,2191,2192,2200,2201,2205],{},"A uniform resource locator (URL) specifies both the location of a resource and a method to access it. According to the Java API documentation for ",[56,2193,2196,2197],{"href":2194,"rel":2195},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002F8\u002Fdocs\u002Fapi\u002F",[1580],"Class ",[43,2198,2199],{},"URL"," [ ",[56,2202,2204],{"href":2203},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-API14","API 2014"," ]:",[2207,2208,2209,2212],"blockquote",{},[39,2210,2211],{},"Two URL objects are equal if they have the same protocol, reference equivalent hosts, have the same port number on the host, and the same file and fragment of the file.",[39,2213,2214],{},"Two hosts are considered equivalent if both host names can be resolved into the same IP addresses; else if either host name can't be resolved, the host names must be equal without regard to case; or both host names equal to null.",[39,2216,2217,2218,2220,2221,2224],{},"The defined behavior for the ",[43,2219,45],{}," method is known to be inconsistent with ",[51,2222,2223],{},"virtual hosting"," in HTTP.",[39,2226,2227,2228,2230,2231,2233],{},"Virtual hosting allows a web server to host multiple websites on the same computer, sometimes sharing the same IP address. Unfortunately, this technique was unanticipated when the ",[43,2229,2199],{}," class was designed. Consequently, when two completely different URLs resolve to the same IP address, the ",[43,2232,2199],{}," class considers them to be equal.",[39,2235,2236,2237,2239,2240,2242,2243,2245,2246,2249,2250,1557],{},"Another risk associated with the ",[43,2238,45],{}," method for ",[43,2241,2199],{}," objects is that the logic it uses when connected to the Internet differs from that used when disconnected. When connected to the Internet, the ",[43,2244,45],{}," method follows the steps described in the Java API; when disconnected, it performs a string compare on the two URLs. Consequently, the ",[43,2247,2248],{},"URL.equals()"," method violates the consistency requirement for ",[43,2251,45],{},[39,2253,2254,2255,2258,2259,2262],{},"Consider an application that allows an organization's employees to access an external mail service via ",[43,2256,2257],{},"http:\u002F\u002Fmailwebsite.com"," . The application is designed to deny access to other websites by behaving as a makeshift firewall. However, a crafty or malicious user could nevertheless access an illegitimate website ",[43,2260,2261],{},"http:\u002F\u002Fillegitimatewebsite.com"," if it were hosted on the same computer as the legitimate website and consequently shared the same IP address. Even worse, if the legitimate website were hosted on a server in a commercial pool of servers, an attacker could register multiple websites in the pool (for phishing purposes) until one was registered on the same computer as the legitimate website, consequently defeating the firewall.",[240,2264,2265],{"quality":242},[244,2266,2268],{"className":246,"code":2267,"language":248,"meta":249,"style":249},"public class Filter {\n public static void main(String[] args) throws MalformedURLException {\n final URL allowed = new URL(\"http:\u002F\u002Fmailwebsite.com\");\n if (!allowed.equals(new URL(args[0]))) {\n throw new SecurityException(\"Access Denied\");\n }\n \u002F\u002F Else proceed\n }\n}\n",[43,2269,2270,2281,2310,2334,2363,2379,2383,2388,2392],{"__ignoreMap":249},[253,2271,2272,2274,2276,2279],{"class":255,"line":256},[253,2273,260],{"class":259},[253,2275,266],{"class":259},[253,2277,2278],{"class":269}," Filter",[253,2280,274],{"class":273},[253,2282,2283,2285,2287,2289,2291,2293,2295,2297,2299,2302,2305,2308],{"class":255,"line":277},[253,2284,299],{"class":259},[253,2286,535],{"class":259},[253,2288,538],{"class":393},[253,2290,541],{"class":302},[253,2292,305],{"class":273},[253,2294,221],{"class":393},[253,2296,548],{"class":273},[253,2298,551],{"class":310},[253,2300,2301],{"class":273},") ",[253,2303,2304],{"class":259},"throws",[253,2306,2307],{"class":283}," MalformedURLException",[253,2309,274],{"class":273},[253,2311,2312,2315,2318,2321,2323,2325,2327,2329,2332],{"class":255,"line":290},[253,2313,2314],{"class":259}," final",[253,2316,2317],{"class":283}," URL",[253,2319,2320],{"class":273}," allowed ",[253,2322,365],{"class":259},[253,2324,340],{"class":259},[253,2326,2317],{"class":302},[253,2328,305],{"class":273},[253,2330,2331],{"class":573},"\"http:\u002F\u002Fmailwebsite.com\"",[253,2333,577],{"class":273},[253,2335,2336,2338,2340,2342,2345,2347,2349,2352,2354,2357,2360],{"class":255,"line":296},[253,2337,320],{"class":259},[253,2339,1034],{"class":273},[253,2341,1037],{"class":259},[253,2343,2344],{"class":273},"allowed.",[253,2346,608],{"class":302},[253,2348,305],{"class":273},[253,2350,2351],{"class":259},"new",[253,2353,2317],{"class":302},[253,2355,2356],{"class":273},"(args[",[253,2358,2359],{"class":328},"0",[253,2361,2362],{"class":273},"]))) {\n",[253,2364,2365,2367,2369,2372,2374,2377],{"class":255,"line":317},[253,2366,337],{"class":259},[253,2368,340],{"class":259},[253,2370,2371],{"class":302}," SecurityException",[253,2373,305],{"class":273},[253,2375,2376],{"class":573},"\"Access Denied\"",[253,2378,577],{"class":273},[253,2380,2381],{"class":255,"line":334},[253,2382,352],{"class":273},[253,2384,2385],{"class":255,"line":349},[253,2386,2387],{"class":384}," \u002F\u002F Else proceed\n",[253,2389,2390],{"class":255,"line":355},[253,2391,373],{"class":273},[253,2393,2394],{"class":255,"line":370},[253,2395,522],{"class":273},[208,2397,2399],{"id":2398},"compliant-solution-strings","Compliant Solution (Strings)",[39,2401,2402,2403,2405],{},"This compliant solution compares the string representations of two URLs, thereby avoiding the pitfalls of ",[43,2404,2248],{}," :",[240,2407,2408],{"quality":688},[244,2409,2411],{"className":246,"code":2410,"language":248,"meta":249,"style":249},"public class Filter {\n public static void main(String[] args) throws MalformedURLException {\n final URL allowed = new URL(\"http:\u002F\u002Fmailwebsite.com\");\n if (!allowed.toString().equals(new URL(args[0]).toString())) {\n throw new SecurityException(\"Access Denied\");\n }\n \u002F\u002F Else proceed\n }\n}\n",[43,2412,2413,2423,2449,2469,2504,2518,2522,2526,2530],{"__ignoreMap":249},[253,2414,2415,2417,2419,2421],{"class":255,"line":256},[253,2416,260],{"class":259},[253,2418,266],{"class":259},[253,2420,2278],{"class":269},[253,2422,274],{"class":273},[253,2424,2425,2427,2429,2431,2433,2435,2437,2439,2441,2443,2445,2447],{"class":255,"line":277},[253,2426,299],{"class":259},[253,2428,535],{"class":259},[253,2430,538],{"class":393},[253,2432,541],{"class":302},[253,2434,305],{"class":273},[253,2436,221],{"class":393},[253,2438,548],{"class":273},[253,2440,551],{"class":310},[253,2442,2301],{"class":273},[253,2444,2304],{"class":259},[253,2446,2307],{"class":283},[253,2448,274],{"class":273},[253,2450,2451,2453,2455,2457,2459,2461,2463,2465,2467],{"class":255,"line":290},[253,2452,2314],{"class":259},[253,2454,2317],{"class":283},[253,2456,2320],{"class":273},[253,2458,365],{"class":259},[253,2460,340],{"class":259},[253,2462,2317],{"class":302},[253,2464,305],{"class":273},[253,2466,2331],{"class":573},[253,2468,577],{"class":273},[253,2470,2471,2473,2475,2477,2479,2482,2485,2487,2489,2491,2493,2495,2497,2500,2502],{"class":255,"line":296},[253,2472,320],{"class":259},[253,2474,1034],{"class":273},[253,2476,1037],{"class":259},[253,2478,2344],{"class":273},[253,2480,2481],{"class":302},"toString",[253,2483,2484],{"class":273},"().",[253,2486,608],{"class":302},[253,2488,305],{"class":273},[253,2490,2351],{"class":259},[253,2492,2317],{"class":302},[253,2494,2356],{"class":273},[253,2496,2359],{"class":328},[253,2498,2499],{"class":273},"]).",[253,2501,2481],{"class":302},[253,2503,2118],{"class":273},[253,2505,2506,2508,2510,2512,2514,2516],{"class":255,"line":317},[253,2507,337],{"class":259},[253,2509,340],{"class":259},[253,2511,2371],{"class":302},[253,2513,305],{"class":273},[253,2515,2376],{"class":573},[253,2517,577],{"class":273},[253,2519,2520],{"class":255,"line":334},[253,2521,352],{"class":273},[253,2523,2524],{"class":255,"line":349},[253,2525,2387],{"class":384},[253,2527,2528],{"class":255,"line":355},[253,2529,373],{"class":273},[253,2531,2532],{"class":255,"line":370},[253,2533,522],{"class":273},[39,2535,2536,2537,2541,2542,2544],{},"This solution still has problems. Two URLs with different string representation can still refer to the same resource. However, the solution ",[56,2538,2540],{"href":2539},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary#RuleBB.Glossary-failsafe","fails safely"," in this case because the ",[43,2543,45],{}," contract is preserved, and the system will never allow a malicious URL to be accepted by mistake.",[208,2546,2548,2549,2552],{"id":2547},"compliant-solution-uriequals","Compliant Solution ( ",[43,2550,2551],{},"URI.equals()"," )",[39,2554,2555,2556,2559,2560,145,2562,2565,2566,145,2568,2571,2572,2575,2576,2580,2581,2583,2584,145,2587,2590,2591,2596,2597,2205],{},"A Uniform Resource Identifier (URI) contains a string of characters used to identify a resource; this is a more general concept than an URL. The ",[43,2557,2558],{},"java.net.URI"," class provides string-based ",[43,2561,45],{},[43,2563,2564],{},"hashCode()"," methods that satisfy the general contracts for ",[43,2567,83],{},[43,2569,2570],{},"Object.hashCode()"," ; they do not invoke hostname resolution and are unaffected by network connectivity. ",[43,2573,2574],{},"URI"," also provides methods for normalization and ",[56,2577,2579],{"href":2578},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary#RuleBB.Glossary-canonicalization","canonicalization"," that ",[43,2582,2199],{}," lacks. Finally, the ",[43,2585,2586],{},"URL.toURI()",[43,2588,2589],{},"URI.toURL()"," methods provide easy conversion between the two classes. Programs should use URIs instead of URLs whenever possible. According to the Java API ",[56,2592,2196,2594],{"href":2194,"rel":2593},[1580],[43,2595,2574],{}," documentation [ ",[56,2598,2204],{"href":2203},[2207,2600,2601],{},[39,2602,2603,2604,2606,2607,2609],{},"A ",[43,2605,2574],{}," may be either absolute or relative. A ",[43,2608,2574],{}," string is parsed according to the generic syntax without regard to the scheme, if any, that it specifies. No lookup of the host, if any, is performed, and no scheme-dependent stream handler is constructed.",[39,2611,2612,2613,2615,2616,2618,2619,2621],{},"This compliant solution uses a ",[43,2614,2574],{}," object instead of a ",[43,2617,2199],{}," . The filter appropriately blocks the website when presented with any string other than ",[43,2620,2257],{}," because the comparison fails.",[240,2623,2624],{"quality":688},[244,2625,2627],{"className":246,"code":2626,"language":248,"meta":249,"style":249},"public class Filter {\n public static void main(String[] args)\n throws MalformedURLException, URISyntaxException {\n final URI allowed = new URI(\"http:\u002F\u002Fmailwebsite.com\");\n if (!allowed.equals(new URI(args[0]))) {\n throw new SecurityException(\"Access Denied\");\n }\n \u002F\u002F Else proceed\n }\n}\n",[43,2628,2629,2639,2660,2674,2695,2719,2733,2737,2741,2745],{"__ignoreMap":249},[253,2630,2631,2633,2635,2637],{"class":255,"line":256},[253,2632,260],{"class":259},[253,2634,266],{"class":259},[253,2636,2278],{"class":269},[253,2638,274],{"class":273},[253,2640,2641,2643,2645,2647,2649,2651,2653,2655,2657],{"class":255,"line":277},[253,2642,299],{"class":259},[253,2644,535],{"class":259},[253,2646,538],{"class":393},[253,2648,541],{"class":302},[253,2650,305],{"class":273},[253,2652,221],{"class":393},[253,2654,548],{"class":273},[253,2656,551],{"class":310},[253,2658,2659],{"class":273},")\n",[253,2661,2662,2665,2667,2669,2672],{"class":255,"line":290},[253,2663,2664],{"class":259}," throws",[253,2666,2307],{"class":283},[253,2668,1159],{"class":273},[253,2670,2671],{"class":283},"URISyntaxException",[253,2673,274],{"class":273},[253,2675,2676,2678,2681,2683,2685,2687,2689,2691,2693],{"class":255,"line":296},[253,2677,2314],{"class":259},[253,2679,2680],{"class":283}," URI",[253,2682,2320],{"class":273},[253,2684,365],{"class":259},[253,2686,340],{"class":259},[253,2688,2680],{"class":302},[253,2690,305],{"class":273},[253,2692,2331],{"class":573},[253,2694,577],{"class":273},[253,2696,2697,2699,2701,2703,2705,2707,2709,2711,2713,2715,2717],{"class":255,"line":317},[253,2698,320],{"class":259},[253,2700,1034],{"class":273},[253,2702,1037],{"class":259},[253,2704,2344],{"class":273},[253,2706,608],{"class":302},[253,2708,305],{"class":273},[253,2710,2351],{"class":259},[253,2712,2680],{"class":302},[253,2714,2356],{"class":273},[253,2716,2359],{"class":328},[253,2718,2362],{"class":273},[253,2720,2721,2723,2725,2727,2729,2731],{"class":255,"line":334},[253,2722,337],{"class":259},[253,2724,340],{"class":259},[253,2726,2371],{"class":302},[253,2728,305],{"class":273},[253,2730,2376],{"class":573},[253,2732,577],{"class":273},[253,2734,2735],{"class":255,"line":349},[253,2736,352],{"class":273},[253,2738,2739],{"class":255,"line":355},[253,2740,2387],{"class":384},[253,2742,2743],{"class":255,"line":370},[253,2744,373],{"class":273},[253,2746,2747],{"class":255,"line":376},[253,2748,522],{"class":273},[39,2750,2751,2752,2754,2755,2758,2759,2761,2762,60],{},"Additionally, the ",[43,2753,2574],{}," class performs normalization (removing extraneous path segments such as \" ",[43,2756,2757],{},".."," \") and relativization of paths [ ",[56,2760,2204],{"href":2203}," ], [ ",[56,2763,2765],{"href":2764},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Darwin04","Darwin 2004",[208,2767,2769,2770,2552],{"id":2768},"noncompliant-code-example-javasecuritykey","Noncompliant Code Example ( ",[43,2771,2772],{},"java.security.Key",[39,2774,2775,2776,2779,2780,2783,2784,2786,2787,2789],{},"The method ",[43,2777,2778],{},"java.lang.Object.equals()"," by default is unable to compare composite objects such as cryptographic keys. Most ",[43,2781,2782],{},"Key"," classes lack an ",[43,2785,45],{}," implementation that would override ",[43,2788,87],{}," 's default implementation. In such cases, the components of the composite object must be compared individually to ensure correctness.",[39,2791,2792,2793,2795],{},"This noncompliant code example compares two keys using the ",[43,2794,45],{}," method. The comparison may return false even when the key instances represent the same logical key.",[240,2797,2798],{"quality":242},[244,2799,2801],{"className":246,"code":2800,"language":248,"meta":249,"style":249},"private static boolean keysEqual(Key key1, Key key2) {\n if (key1.equals(key2)) {\n return true;\n }\n return false;\n}\n",[43,2802,2803,2827,2840,2849,2853,2862],{"__ignoreMap":249},[253,2804,2805,2808,2810,2812,2815,2817,2819,2822,2824],{"class":255,"line":256},[253,2806,2807],{"class":259},"private",[253,2809,535],{"class":259},[253,2811,394],{"class":393},[253,2813,2814],{"class":302}," keysEqual",[253,2816,305],{"class":273},[253,2818,2782],{"class":283},[253,2820,2821],{"class":273}," key1, ",[253,2823,2782],{"class":283},[253,2825,2826],{"class":273}," key2) {\n",[253,2828,2829,2832,2835,2837],{"class":255,"line":277},[253,2830,2831],{"class":259}," if",[253,2833,2834],{"class":273}," (key1.",[253,2836,608],{"class":302},[253,2838,2839],{"class":273},"(key2)) {\n",[253,2841,2842,2844,2847],{"class":255,"line":290},[253,2843,480],{"class":259},[253,2845,2846],{"class":328}," true",[253,2848,486],{"class":273},[253,2850,2851],{"class":255,"line":296},[253,2852,373],{"class":273},[253,2854,2855,2858,2860],{"class":255,"line":317},[253,2856,2857],{"class":259}," return",[253,2859,483],{"class":328},[253,2861,486],{"class":273},[253,2863,2864],{"class":255,"line":334},[253,2865,522],{"class":273},[208,2867,2548,2869,2552],{"id":2868},"compliant-solution-javasecuritykey",[43,2870,2772],{},[39,2872,2873,2874,2876,2877,145,2880,2883,2884,60],{},"This compliant solution uses the ",[43,2875,45],{}," method as a first test and then compares the encoded version of the keys to facilitate provider-independent behavior. For example, this code can determine whether a ",[43,2878,2879],{},"RSAPrivateKey",[43,2881,2882],{},"RSAPrivateCrtKey"," represent equivalent private keys [ ",[56,2885,2887],{"href":2886},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Sun06","Sun 2006",[240,2889,2890],{"quality":688},[244,2891,2893],{"className":246,"code":2892,"language":248,"meta":249,"style":249},"private static boolean keysEqual(Key key1, Key key2) {\n if (key1.equals(key2)) {\n return true;\n }\n\n if (Arrays.equals(key1.getEncoded(), key2.getEncoded())) {\n return true;\n }\n\n \u002F\u002F More code for different types of keys here.\n \u002F\u002F For example, the following code can check if\n \u002F\u002F an RSAPrivateKey and an RSAPrivateCrtKey are equal:\n if ((key1 instanceof RSAPrivateKey) &&\n (key2 instanceof RSAPrivateKey)) {\n \n if ((((RSAKey)key1).getModulus().equals(\n ((RSAKey)key2).getModulus())) &&\n (((RSAPrivateKey) key1).getPrivateExponent().equals(\n ((RSAPrivateKey) key2).getPrivateExponent()))) {\n return true;\n }\n }\n return false;\n}\n",[43,2894,2895,2915,2925,2933,2937,2941,2963,2971,2975,2979,2984,2989,2994,3008,3018,3023,3040,3052,3066,3076,3084,3088,3092,3100],{"__ignoreMap":249},[253,2896,2897,2899,2901,2903,2905,2907,2909,2911,2913],{"class":255,"line":256},[253,2898,2807],{"class":259},[253,2900,535],{"class":259},[253,2902,394],{"class":393},[253,2904,2814],{"class":302},[253,2906,305],{"class":273},[253,2908,2782],{"class":283},[253,2910,2821],{"class":273},[253,2912,2782],{"class":283},[253,2914,2826],{"class":273},[253,2916,2917,2919,2921,2923],{"class":255,"line":277},[253,2918,2831],{"class":259},[253,2920,2834],{"class":273},[253,2922,608],{"class":302},[253,2924,2839],{"class":273},[253,2926,2927,2929,2931],{"class":255,"line":290},[253,2928,480],{"class":259},[253,2930,2846],{"class":328},[253,2932,486],{"class":273},[253,2934,2935],{"class":255,"line":296},[253,2936,373],{"class":273},[253,2938,2939],{"class":255,"line":317},[253,2940,293],{"emptyLinePlaceholder":7},[253,2942,2943,2945,2948,2950,2953,2956,2959,2961],{"class":255,"line":334},[253,2944,2831],{"class":259},[253,2946,2947],{"class":273}," (Arrays.",[253,2949,608],{"class":302},[253,2951,2952],{"class":273},"(key1.",[253,2954,2955],{"class":302},"getEncoded",[253,2957,2958],{"class":273},"(), key2.",[253,2960,2955],{"class":302},[253,2962,2118],{"class":273},[253,2964,2965,2967,2969],{"class":255,"line":349},[253,2966,480],{"class":259},[253,2968,2846],{"class":328},[253,2970,486],{"class":273},[253,2972,2973],{"class":255,"line":355},[253,2974,373],{"class":273},[253,2976,2977],{"class":255,"line":370},[253,2978,293],{"emptyLinePlaceholder":7},[253,2980,2981],{"class":255,"line":376},[253,2982,2983],{"class":384}," \u002F\u002F More code for different types of keys here.\n",[253,2985,2986],{"class":255,"line":381},[253,2987,2988],{"class":384}," \u002F\u002F For example, the following code can check if\n",[253,2990,2991],{"class":255,"line":388},[253,2992,2993],{"class":384}," \u002F\u002F an RSAPrivateKey and an RSAPrivateCrtKey are equal:\n",[253,2995,2996,2998,3001,3003,3006],{"class":255,"line":409},[253,2997,2831],{"class":259},[253,2999,3000],{"class":273}," ((key1 ",[253,3002,417],{"class":259},[253,3004,3005],{"class":273}," RSAPrivateKey) ",[253,3007,806],{"class":259},[253,3009,3010,3013,3015],{"class":255,"line":423},[253,3011,3012],{"class":273}," (key2 ",[253,3014,417],{"class":259},[253,3016,3017],{"class":273}," RSAPrivateKey)) {\n",[253,3019,3020],{"class":255,"line":438},[253,3021,3022],{"class":273}," \n",[253,3024,3025,3027,3030,3033,3035,3037],{"class":255,"line":443},[253,3026,320],{"class":259},[253,3028,3029],{"class":273}," ((((RSAKey)key1).",[253,3031,3032],{"class":302},"getModulus",[253,3034,2484],{"class":273},[253,3036,608],{"class":302},[253,3038,3039],{"class":273},"(\n",[253,3041,3042,3045,3047,3050],{"class":255,"line":448},[253,3043,3044],{"class":273}," ((RSAKey)key2).",[253,3046,3032],{"class":302},[253,3048,3049],{"class":273},"())) ",[253,3051,806],{"class":259},[253,3053,3054,3057,3060,3062,3064],{"class":255,"line":460},[253,3055,3056],{"class":273}," (((RSAPrivateKey) key1).",[253,3058,3059],{"class":302},"getPrivateExponent",[253,3061,2484],{"class":273},[253,3063,608],{"class":302},[253,3065,3039],{"class":273},[253,3067,3068,3071,3073],{"class":255,"line":472},[253,3069,3070],{"class":273}," ((RSAPrivateKey) key2).",[253,3072,3059],{"class":302},[253,3074,3075],{"class":273},"()))) {\n",[253,3077,3078,3080,3082],{"class":255,"line":477},[253,3079,426],{"class":259},[253,3081,2846],{"class":328},[253,3083,486],{"class":273},[253,3085,3086],{"class":255,"line":489},[253,3087,352],{"class":273},[253,3089,3090],{"class":255,"line":494},[253,3091,373],{"class":273},[253,3093,3094,3096,3098],{"class":255,"line":499},[253,3095,2857],{"class":259},[253,3097,483],{"class":328},[253,3099,486],{"class":273},[253,3101,3102],{"class":255,"line":505},[253,3103,522],{"class":273},[208,3105,3107],{"id":3106},"exceptions","Exceptions",[39,3109,3110,3114,3115,3118,3119,3122,3123,3125,3126,3129,3130,145,3132,3135,3136,60],{},[3111,3112,3113],"strong",{},"MET08-J-EX0:"," Requirements of this rule may be violated provided that the incompatible types are never compared. There are classes in the Java platform libraries (and elsewhere) that extend an instantiable class by adding a value component. For example, ",[43,3116,3117],{},"java.sql.Timestamp"," extends ",[43,3120,3121],{},"java.util.Date"," and adds a nanoseconds field. The ",[43,3124,45],{}," implementation for ",[43,3127,3128],{},"Timestamp"," violates symmetry and can cause erratic behavior when ",[43,3131,3128],{},[43,3133,3134],{},"Date"," objects are used in the same collection or are otherwise intermixed [ ",[56,3137,1574],{"href":1573},[208,3139,3141],{"id":3140},"risk-assessment","Risk Assessment",[39,3143,3144,3145,3147],{},"Violating the general contract when overriding the ",[43,3146,45],{}," method can lead to unexpected results.",[3149,3150,3151,3152,3151,3182],"table",{},"\n ",[3153,3154,3155,3156,3151],"thead",{},"\n ",[3157,3158,3159,3160,3159,3164,3159,3167,3159,3170,3159,3173,3159,3176,3159,3179,3155],"tr",{},"\n ",[3161,3162,3163],"th",{},"Rule",[3161,3165,3166],{},"Severity",[3161,3168,3169],{},"Likelihood",[3161,3171,3172],{},"Detectable",[3161,3174,3175],{},"Repairable",[3161,3177,3178],{},"Priority",[3161,3180,3181],{},"Level",[3183,3184,3155,3185,3151],"tbody",{},[3157,3186,3159,3187,3159,3191,3159,3194,3159,3197,3159,3200,3159,3202,3159,3209,3155],{},[3188,3189,3190],"td",{},"MET08-J",[3188,3192,3193],{},"Low",[3188,3195,3196],{},"Unlikely",[3188,3198,3199],{},"No",[3188,3201,3199],{},[3188,3203,3205],{"style":3204},"color: #27ae60;",[3206,3207,3208],"b",{},"P1",[3188,3210,3211],{"style":3204},[3206,3212,3213],{},"L3",[3215,3216,3218],"h3",{"id":3217},"automated-detection","Automated Detection",[3149,3220,3223],{"className":3221},[3222],"wrapped",[3183,3224,3225,3241,3296,3322],{},[3157,3226,3229,3232,3235,3238],{"className":3227},[3228],"header",[3161,3230,3231],{},"Tool",[3161,3233,3234],{},"Version",[3161,3236,3237],{},"Checker",[3161,3239,3240],{},"Description",[3157,3242,3245,3251,3259,3282],{"className":3243},[3244],"odd",[3188,3246,3247],{},[56,3248,3250],{"href":3249},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcodesonar","CodeSonar",[3188,3252,3253],{},[3254,3255,3258],"div",{"className":3256},[3257],"content-wrapper","9.0p0",[3188,3260,3261],{},[39,3262,3263,3266,3269,3272,3274,3277,3279],{},[3111,3264,3265],{},"JAVA.COMPARE.CTO.ASSYM",[3267,3268],"br",{},[3111,3270,3271],{},"JAVA.IDEF.NOEQUALS",[3267,3273],{},[3111,3275,3276],{},"JAVA.IDEF.CTONOEQ",[3267,3278],{},[3111,3280,3281],{},"JAVA.IDEF.CTOEQ",[3188,3283,3284],{},[39,3285,3286,3287,3289,3290,3292,3293,3295],{},"Asymmetric compareTo (Java)",[3267,3288],{},"\nMissing Equals Override (Java)",[3267,3291],{},"\ncompareTo without equals (Java)",[3267,3294],{},"\ncompareTo\u002Fequals mismatch (Java)",[3157,3297,3300,3306,3314,3319],{"className":3298},[3299],"even",[3188,3301,3302],{},[56,3303,3305],{"href":3304},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fparasoft","Parasoft Jtest",[3188,3307,3308],{},[3254,3309,3311],{"className":3310},[3257],[39,3312,3313],{},"2025.2",[3188,3315,3316],{},[3111,3317,3318],{},"CERT.MET08.EQREFL",[3188,3320,3321],{},"Make sure implementation of Object.equals(Object) is reflexive",[3157,3323,3325,3331,3337,3345],{"className":3324},[3244],[3188,3326,3327],{},[56,3328,3330],{"href":3329},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fsonarqube","SonarQube",[3188,3332,3333],{},[3254,3334,3336],{"className":3335},[3257],"9.9",[3188,3338,3339],{},[3111,3340,3341],{},[56,3342,3344],{"href":3343},"https:\u002F\u002Frules.sonarsource.com\u002Fjava\u002FRSPEC-2162","S2162",[3188,3346,3347],{},[56,3348,3349],{"href":3343},"\"equals\" methods should be symmetric and work for subclasses",[208,3351,3353],{"id":3352},"related-guidelines","Related Guidelines",[3149,3355,3356,3364],{},[3153,3357,3358],{},[3157,3359,3360,3362],{},[3161,3361],{},[3161,3363],{},[3183,3365,3366],{},[3157,3367,3368,3375],{},[3188,3369,3370],{},[56,3371,3374],{"href":3372,"rel":3373},"http:\u002F\u002Fcwe.mitre.org\u002F",[1580],"MITRE CWE",[3188,3376,3377,3382],{},[56,3378,3381],{"href":3379,"rel":3380},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F697.html",[1580],"CWE-697"," , Insufficient Comparison",[208,3384,3386],{"id":3385},"bibliography","Bibliography",[3149,3388,3390],{"className":3389},[3222],[3183,3391,3392,3421,3439,3450,3467,3483,3544,3562],{},[3157,3393,3395,3401],{"className":3394},[3244],[3188,3396,3397,3398,3400],{},"[ ",[56,3399,2204],{"href":2203}," ]",[3188,3402,3403,3408,3409,3417,3418,2552],{},[56,3404,2196,3405],{"href":2194},[43,3406,3407],{}," URI "," ",[56,3410,3411,3413,3414],{"href":2194},[3267,3412],{},"\nClass ",[43,3415,3416],{}," URL "," (method ",[43,3419,3420],{}," equals() ",[3157,3422,3424,3430],{"className":3423},[3299],[3188,3425,3426],{},[39,3427,3397,3428,3400],{},[56,3429,1574],{"href":1573},[3188,3431,3432],{},[39,3433,3434,3435,3438],{},"Item 8, \"Obey the General Contract When Overriding ",[43,3436,3437],{}," equals "," \"",[3157,3440,3442,3446],{"className":3441},[3244],[3188,3443,3397,3444,3400],{},[56,3445,1581],{"href":1578},[3188,3447,3448],{},[3267,3449],{},[3157,3451,3453,3459],{"className":3452},[3299],[3188,3454,3455],{},[39,3456,3397,3457,3400],{},[56,3458,2765],{"href":2764},[3188,3460,3461],{},[39,3462,3463,3464,3466],{},"Section 9.2, \"Overriding the ",[43,3465,3437],{}," Method\"",[3157,3468,3470,3478],{"className":3469},[3244],[3188,3471,3472],{},[39,3473,3397,3474,3400],{},[56,3475,3477],{"href":3476},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Harold97","Harold 1997",[3188,3479,3480],{},[39,3481,3482],{},"Chapter 3, \"Classes, Strings, and Arrays,\" section \"The Object Class (Equality)\"",[3157,3484,3486,3489],{"className":3485},[3299],[3188,3487,3488],{},"[Liskov 1994]",[3188,3490,3491],{},[39,3492,3493,3497,3498,3502,3503,3506,3507,3408,3513,3516,3517,3521,3522,3526,3527,3497,3530,3533,3534,3538,3539,3543],{},[56,3494,3496],{"href":3495},"https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FBarbara_Liskov","Liskov, B. H."," ; ",[56,3499,3501],{"href":3500},"https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FJeannette_Wing","Wing, J. M."," (November 1994). ",[51,3504,3505],{},"A behavioral notion of subtyping"," . ",[51,3508,3509],{},[56,3510,3512],{"href":3511},"https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FACM_Transactions_on_Programming_Languages_and_Systems","ACM Trans. Program. Lang. Syst.",[3111,3514,3515],{},"16"," (6). pp. 1811–1841. ",[56,3518,3520],{"href":3519},"https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FDigital_object_identifier","doi"," : ",[56,3523,3525],{"href":3524},"https:\u002F\u002Fdoi.org\u002F10.1145%2F197320.197383","10.1145\u002F197320.197383"," . An updated version appeared as CMU technical report: ",[56,3528,3529],{"href":3495},"Liskov, Barbara",[56,3531,3532],{"href":3500},"Wing, Jeannette"," (July 1999). ",[56,3535,3537],{"href":3536},"http:\u002F\u002Freports-archive.adm.cs.cmu.edu\u002Fanon\u002F1999\u002FCMU-CS-99-156.ps","\"Behavioral Subtyping Using Invariants and Constraints\""," ( ",[56,3540,3542],{"href":3541},"https:\u002F\u002Fen.wikipedia.org\u002Fwiki\u002FPostScript","PS"," ) .",[3157,3545,3547,3553],{"className":3546},[3244],[3188,3548,3549],{},[39,3550,3397,3551,3400],{},[56,3552,2887],{"href":2886},[3188,3554,3555],{},[39,3556,3557,3561],{},[56,3558,3560],{"href":3559},"http:\u002F\u002Fjava.sun.com\u002Fjavase\u002F6\u002Fdocs\u002Ftechnotes\u002Fguides\u002Fsecurity\u002Fcrypto\u002FCryptoSpec.html#Determining%20If%20Two%20Keys%20Are%20Equal","Determining If Two Keys Are Equal"," (JCA Reference Guide)",[3157,3563,3565,3573],{"className":3564},[3299],[3188,3566,3567],{},[39,3568,3397,3569,3400],{},[56,3570,3572],{"href":3571},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Techtalk07","Techtalk 2007",[3188,3574,3575],{},[39,3576,3577],{},"\"More Joy of Sets\"",[3579,3580],"hr",{},[39,3582,3583,3408,3590,3408,3596],{},[56,3584,3586],{"href":3585},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet07-j",[3587,3588],"img",{"src":3589},"\u002Fattachments\u002F88487702\u002F88497198.png",[56,3591,3593],{"href":3592},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002F",[3587,3594],{"src":3595},"\u002Fattachments\u002F88487702\u002F88497196.png",[56,3597,3599],{"href":3598},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet09-j",[3587,3600],{"src":3601},"\u002Fattachments\u002F88487702\u002F88497197.png",[3603,3604,3605],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sz2Vg, html code.shiki .sz2Vg{--shiki-default:#6F42C1;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-text-decoration:underline}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sk8M1, html code.shiki .sk8M1{--shiki-default:#24292E;--shiki-default-font-style:inherit;--shiki-dark:#E1E4E8;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .sP7S_, html code.shiki .sP7S_{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#FD971F}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html pre.shiki code .s30JN, html code.shiki .s30JN{--shiki-default:#6F42C1;--shiki-default-font-style:inherit;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-font-style:inherit;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-font-style:italic;--shiki-sepia-text-decoration:underline}",{"title":249,"searchDepth":277,"depth":277,"links":3607},[3608,3609,3610,3611,3612,3613,3614,3615,3617,3619,3621,3622,3625,3626],{"id":210,"depth":277,"text":211},{"id":675,"depth":277,"text":676},{"id":932,"depth":277,"text":933},{"id":1560,"depth":277,"text":1561},{"id":2003,"depth":277,"text":2004},{"id":2187,"depth":277,"text":2188},{"id":2398,"depth":277,"text":2399},{"id":2547,"depth":277,"text":3616},"Compliant Solution ( URI.equals() )",{"id":2768,"depth":277,"text":3618},"Noncompliant Code Example ( java.security.Key )",{"id":2868,"depth":277,"text":3620},"Compliant Solution ( java.security.Key )",{"id":3106,"depth":277,"text":3107},{"id":3140,"depth":277,"text":3141,"children":3623},[3624],{"id":3217,"depth":290,"text":3218},{"id":3352,"depth":277,"text":3353},{"id":3385,"depth":277,"text":3386},"Composition or inheritance may be used to create a new class that both encapsulates an existing class and adds one or more fields. When one class extends another in this way, the concept of equality for the subclass may or may not involve its new fields. That is, when comparing two subclass objects for equality, sometimes their respective fields must also be equal, and other times they need not be equal. Depending on the concept of equality for the subclass, the subclass might override equals() . Furthermore, this method must follow the general contract for equals() , as specified by The Java Language Specification (JLS) [ JLS 2015 ].","md",{"tags":3630},[3631,3632,3633,3634,3635],"met","android-applicable","android","analyzable","rule","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet08-j",{"title":30,"description":3627},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F10.met08-j","FBWKtZYZobGQCq0UnhJL-uha_r0zxtI4RiW7ywmNSLM",[3641,3644],{"title":3642,"path":3585,"stem":3643,"children":-1},"MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F09.met07-j",{"title":3645,"path":3598,"stem":3646,"children":-1},"MET09-J. Classes that define an equals() method must also define a hashCode() method","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F11.met09-j",[3648],{"title":3649,"path":3650,"stem":3651,"children":3652},"SEI CERT Oracle Coding Standard for Java","\u002Fsei-cert-oracle-coding-standard-for-java","6.sei-cert-oracle-coding-standard-for-java\u002F1.index",[3653,3654,3794,4623,5022,5194],{"title":3649,"path":3650,"stem":3651},{"title":3655,"path":3656,"stem":3657,"children":3658},"Front Matter","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F1.index",[3659,3660,3664,3668,3672,3718,3756],{"title":3655,"path":3656,"stem":3657},{"title":3661,"path":3662,"stem":3663},"Rules versus Recommendations (Java)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frules-versus-recommendations-java","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F2.rules-versus-recommendations-java",{"title":3665,"path":3666,"stem":3667},"Acknowledgments","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Facknowledgments","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F3.acknowledgments",{"title":3669,"path":3670,"stem":3671},"Deprecations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Fdeprecations","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.deprecations",{"title":3673,"path":3674,"stem":3675,"children":3676},"Rec. Preface","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F01.index",[3677,3678,3682,3686,3690,3694,3698,3702,3706,3710,3714],{"title":3673,"path":3674,"stem":3675},{"title":3679,"path":3680,"stem":3681},"Scope","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fscope","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F02.scope",{"title":3683,"path":3684,"stem":3685},"Audience","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Faudience","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F03.audience",{"title":3687,"path":3688,"stem":3689},"Contents and Organization","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fcontents-and-organization","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F05.contents-and-organization",{"title":3691,"path":3692,"stem":3693},"Guidelines","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fguidelines","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F06.guidelines",{"title":3695,"path":3696,"stem":3697},"Usage","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fusage","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F07.usage",{"title":3699,"path":3700,"stem":3701},"System Qualities","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fsystem-qualities","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F08.system-qualities",{"title":3703,"path":3704,"stem":3705},"Priority and Levels","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fpriority-and-levels","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F09.priority-and-levels",{"title":3707,"path":3708,"stem":3709},"Automatically Generated Code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fautomatically-generated-code","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F10.automatically-generated-code",{"title":3711,"path":3712,"stem":3713},"Source Code Validation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Fsource-code-validation","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F11.source-code-validation",{"title":3715,"path":3716,"stem":3717},"Tool Selection and Validation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frec-preface\u002Ftool-selection-and-validation","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F4.rec-preface\u002F12.tool-selection-and-validation",{"title":3719,"path":3720,"stem":3721,"children":3722},"Rule. Introduction","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F01.index",[3723,3724,3728,3732,3736,3740,3744,3748,3752],{"title":3719,"path":3720,"stem":3721},{"title":3725,"path":3726,"stem":3727},"Input Validation and Data Sanitization","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Finput-validation-and-data-sanitization","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F02.input-validation-and-data-sanitization",{"title":3729,"path":3730,"stem":3731},"Leaking Sensitive Data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Fleaking-sensitive-data","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F03.leaking-sensitive-data",{"title":3733,"path":3734,"stem":3735},"Type Safety","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Ftype-safety","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F04.type-safety",{"title":3737,"path":3738,"stem":3739},"Leaking Capabilities","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Fleaking-capabilities","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F05.leaking-capabilities",{"title":3741,"path":3742,"stem":3743},"Denial of Service","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Fdenial-of-service","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F06.denial-of-service",{"title":3745,"path":3746,"stem":3747},"Libraries","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Flibraries","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F07.libraries",{"title":3749,"path":3750,"stem":3751},"Concurrency, Visibility, and Memory","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Fconcurrency-visibility-and-memory","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F08.concurrency-visibility-and-memory",{"title":3753,"path":3754,"stem":3755},"Privilege Escalation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-introduction\u002Fprivilege-escalation","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F5.rule-introduction\u002F09.privilege-escalation",{"title":3757,"path":3758,"stem":3759,"children":3760},"Rule. Preface","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F01.index",[3761,3762,3765,3768,3771,3775,3778,3781,3784,3787,3791],{"title":3757,"path":3758,"stem":3759},{"title":3679,"path":3763,"stem":3764},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fscope","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F02.scope",{"title":3683,"path":3766,"stem":3767},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Faudience","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F03.audience",{"title":3687,"path":3769,"stem":3770},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fcontents-and-organization","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F04.contents-and-organization",{"title":3772,"path":3773,"stem":3774},"Identifiers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fidentifiers","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F05.identifiers",{"title":3695,"path":3776,"stem":3777},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fusage","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F06.usage",{"title":3699,"path":3779,"stem":3780},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fsystem-qualities","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F07.system-qualities",{"title":3703,"path":3782,"stem":3783},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fpriority-and-levels","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F08.priority-and-levels",{"title":3707,"path":3785,"stem":3786},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fautomatically-generated-code","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F09.automatically-generated-code",{"title":3788,"path":3789,"stem":3790},"Conformance Testing","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Fconformance-testing","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F10.conformance-testing",{"title":3715,"path":3792,"stem":3793},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter\u002Frule-preface\u002Ftool-selection-and-validation","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F6.rule-preface\u002F11.tool-selection-and-validation",{"title":3795,"path":3796,"stem":3797,"children":3798},"Rules","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F01.index",[3799,3800,3804,3830,3848,3894,3932,4006,4060,4086,4140,4193,4247,4305,4367,4417,4457,4515,4545,4571,4593],{"title":3795,"path":3796,"stem":3797},{"title":3801,"path":3802,"stem":3803},"Android (DRD)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fandroid-drd","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F02.android-drd",{"title":3805,"path":3806,"stem":3807,"children":3808},"Characters and Strings (STR)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F1.index",[3809,3810,3814,3818,3822,3826],{"title":3805,"path":3806,"stem":3807},{"title":3811,"path":3812,"stem":3813},"STR00-J. Don't form strings containing partial characters from variable-width encodings","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str\u002Fstr00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F2.str00-j",{"title":3815,"path":3816,"stem":3817},"STR01-J. Do not assume that a Java char fully represents a Unicode code point","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str\u002Fstr01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F3.str01-j",{"title":3819,"path":3820,"stem":3821},"STR02-J. Specify an appropriate locale when comparing locale-dependent data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str\u002Fstr02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F4.str02-j",{"title":3823,"path":3824,"stem":3825},"STR03-J. Do not encode noncharacter data as a string","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str\u002Fstr03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F5.str03-j",{"title":3827,"path":3828,"stem":3829},"STR04-J. Use compatible character encodings when communicating string data between JVMs","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fcharacters-and-strings-str\u002Fstr04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F03.characters-and-strings-str\u002F6.str04-j",{"title":3831,"path":3832,"stem":3833,"children":3834},"Declarations and Initialization (DCL)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fdeclarations-and-initialization-dcl","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F04.declarations-and-initialization-dcl\u002F1.index",[3835,3836,3840,3844],{"title":3831,"path":3832,"stem":3833},{"title":3837,"path":3838,"stem":3839},"DCL00-J. Prevent class initialization cycles","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F04.declarations-and-initialization-dcl\u002F2.dcl00-j",{"title":3841,"path":3842,"stem":3843},"DCL01-J. Do not reuse public identifiers from the Java Standard Library","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F04.declarations-and-initialization-dcl\u002F3.dcl01-j",{"title":3845,"path":3846,"stem":3847},"DCL02-J. Do not modify the collection's elements during an enhanced for statement","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F04.declarations-and-initialization-dcl\u002F4.dcl02-j",{"title":3849,"path":3850,"stem":3851,"children":3852},"Exceptional Behavior (ERR)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F01.index",[3853,3854,3858,3862,3866,3870,3874,3878,3882,3886,3890],{"title":3849,"path":3850,"stem":3851},{"title":3855,"path":3856,"stem":3857},"ERR00-J. Do not suppress or ignore checked exceptions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F02.err00-j",{"title":3859,"path":3860,"stem":3861},"ERR01-J. Do not allow exceptions to expose sensitive information","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F03.err01-j",{"title":3863,"path":3864,"stem":3865},"ERR02-J. Prevent exceptions while logging data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F04.err02-j",{"title":3867,"path":3868,"stem":3869},"ERR03-J. Restore prior object state on method failure","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F05.err03-j",{"title":3871,"path":3872,"stem":3873},"ERR04-J. Do not complete abruptly from a finally block","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F06.err04-j",{"title":3875,"path":3876,"stem":3877},"ERR05-J. Do not let checked exceptions escape from a finally block","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F07.err05-j",{"title":3879,"path":3880,"stem":3881},"ERR06-J. Do not throw undeclared checked exceptions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F08.err06-j",{"title":3883,"path":3884,"stem":3885},"ERR07-J. Do not throw RuntimeException, Exception, or Throwable","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F09.err07-j",{"title":3887,"path":3888,"stem":3889},"ERR08-J. Do not catch NullPointerException or any of its ancestors","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F10.err08-j",{"title":3891,"path":3892,"stem":3893},"ERR09-J. Do not allow untrusted code to terminate the JVM","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexceptional-behavior-err\u002Ferr09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F05.exceptional-behavior-err\u002F11.err09-j",{"title":3895,"path":3896,"stem":3897,"children":3898},"Expressions (EXP)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F1.index",[3899,3900,3904,3908,3912,3916,3920,3924,3928],{"title":3895,"path":3896,"stem":3897},{"title":3901,"path":3902,"stem":3903},"EXP00-J. Do not ignore values returned by methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F2.exp00-j",{"title":3905,"path":3906,"stem":3907},"EXP01-J. Do not use a null in a case where an object is required","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F3.exp01-j",{"title":3909,"path":3910,"stem":3911},"EXP02-J. Do not use the Object.equals() method to compare two arrays","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F4.exp02-j",{"title":3913,"path":3914,"stem":3915},"EXP03-J. Do not use the equality operators when comparing values of boxed primitives","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F5.exp03-j",{"title":3917,"path":3918,"stem":3919},"EXP04-J. Do not pass arguments to certain Java Collections Framework methods that are a different type than the collection parameter type","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F6.exp04-j",{"title":3921,"path":3922,"stem":3923},"EXP05-J. Do not follow a write by a subsequent write or read of the same object within an expression","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F7.exp05-j",{"title":3925,"path":3926,"stem":3927},"EXP06-J. Expressions used in assertions must not produce side effects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F8.exp06-j",{"title":3929,"path":3930,"stem":3931},"EXP07-J. Prevent loss of useful data due to weak references","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fexpressions-exp\u002Fexp07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F06.expressions-exp\u002F9.exp07-j",{"title":3933,"path":3934,"stem":3935,"children":3936},"Input Output (FIO)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F01.index",[3937,3938,3942,3946,3950,3954,3958,3962,3966,3970,3974,3978,3982,3986,3990,3994,3998,4002],{"title":3933,"path":3934,"stem":3935},{"title":3939,"path":3940,"stem":3941},"FIO00-J. Do not operate on files in shared directories","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F02.fio00-j",{"title":3943,"path":3944,"stem":3945},"FIO01-J. Create files with appropriate access permissions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F03.fio01-j",{"title":3947,"path":3948,"stem":3949},"FIO02-J. Detect and handle file-related errors","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F04.fio02-j",{"title":3951,"path":3952,"stem":3953},"FIO03-J. Remove temporary files before termination","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F05.fio03-j",{"title":3955,"path":3956,"stem":3957},"FIO04-J. Release resources when they are no longer needed","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F06.fio04-j",{"title":3959,"path":3960,"stem":3961},"FIO05-J. Do not expose buffers or their backing arrays methods to untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F07.fio05-j",{"title":3963,"path":3964,"stem":3965},"FIO06-J. Do not create multiple buffered wrappers on a single byte or character stream","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F08.fio06-j",{"title":3967,"path":3968,"stem":3969},"FIO07-J. Do not let external processes block on IO buffers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F09.fio07-j",{"title":3971,"path":3972,"stem":3973},"FIO08-J. Distinguish between characters or bytes read from a stream and -1","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F10.fio08-j",{"title":3975,"path":3976,"stem":3977},"FIO09-J. Do not rely on the write() method to output integers outside the range 0 to 255","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F11.fio09-j",{"title":3979,"path":3980,"stem":3981},"FIO10-J. Ensure the array is filled when using read() to fill an array","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F12.fio10-j",{"title":3983,"path":3984,"stem":3985},"FIO11-J. Do not convert between strings and bytes without specifying a valid character encoding","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F13.fio11-j",{"title":3987,"path":3988,"stem":3989},"FIO12-J. Provide methods to read and write little-endian data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio12-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F14.fio12-j",{"title":3991,"path":3992,"stem":3993},"FIO13-J. Do not log sensitive information outside a trust boundary","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio13-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F15.fio13-j",{"title":3995,"path":3996,"stem":3997},"FIO14-J. Perform proper cleanup at program termination","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio14-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F16.fio14-j",{"title":3999,"path":4000,"stem":4001},"FIO15-J. Do not reset a servlet's output stream after committing it","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio15-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F17.fio15-j",{"title":4003,"path":4004,"stem":4005},"FIO16-J. Canonicalize path names before validating them","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-output-fio\u002Ffio16-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F07.input-output-fio\u002F18.fio16-j",{"title":4007,"path":4008,"stem":4009,"children":4010},"Input Validation and Data Sanitization (IDS)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F01.index",[4011,4012,4016,4020,4024,4028,4032,4036,4040,4044,4048,4052,4056],{"title":4007,"path":4008,"stem":4009},{"title":4013,"path":4014,"stem":4015},"IDS00-J. Prevent SQL injection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F02.ids00-j",{"title":4017,"path":4018,"stem":4019},"IDS01-J. Normalize strings before validating them","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F03.ids01-j",{"title":4021,"path":4022,"stem":4023},"IDS03-J. Do not log unsanitized user input","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F04.ids03-j",{"title":4025,"path":4026,"stem":4027},"IDS04-J. Safely extract files from ZipInputStream","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F05.ids04-j",{"title":4029,"path":4030,"stem":4031},"IDS06-J. Exclude unsanitized user input from format strings","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F06.ids06-j",{"title":4033,"path":4034,"stem":4035},"IDS07-J. Sanitize untrusted data passed to the Runtime.exec() method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F07.ids07-j",{"title":4037,"path":4038,"stem":4039},"IDS08-J. Sanitize untrusted data included in a regular expression","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F08.ids08-j",{"title":4041,"path":4042,"stem":4043},"IDS11-J. Perform any string modifications before validation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F09.ids11-j",{"title":4045,"path":4046,"stem":4047},"IDS14-J. Do not trust the contents of hidden form fields","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids14-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F10.ids14-j",{"title":4049,"path":4050,"stem":4051},"IDS15-J. Do not allow sensitive information to leak outside a trust boundary","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids15-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F11.ids15-j",{"title":4053,"path":4054,"stem":4055},"IDS16-J. Prevent XML Injection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids16-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F12.ids16-j",{"title":4057,"path":4058,"stem":4059},"IDS17-J. Prevent XML External Entity Attacks","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Finput-validation-and-data-sanitization-ids\u002Fids17-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F08.input-validation-and-data-sanitization-ids\u002F13.ids17-j",{"title":4061,"path":4062,"stem":4063,"children":4064},"Java Native Interface (JNI)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F1.index",[4065,4066,4070,4074,4078,4082],{"title":4061,"path":4062,"stem":4063},{"title":4067,"path":4068,"stem":4069},"JNI00-J. Define wrappers around native methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni\u002Fjni00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F2.jni00-j",{"title":4071,"path":4072,"stem":4073},"JNI01-J. Safely invoke standard APIs that perform tasks using the immediate caller's class loader instance (loadLibrary)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni\u002Fjni01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F3.jni01-j",{"title":4075,"path":4076,"stem":4077},"JNI02-J. Do not assume object references are constant or unique","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni\u002Fjni02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F4.jni02-j",{"title":4079,"path":4080,"stem":4081},"JNI03-J. Do not use direct pointers to Java objects in JNI code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni\u002Fjni03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F5.jni03-j",{"title":4083,"path":4084,"stem":4085},"JNI04-J. Do not assume that Java strings are null-terminated","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fjava-native-interface-jni\u002Fjni04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F09.java-native-interface-jni\u002F6.jni04-j",{"title":4087,"path":4088,"stem":4089,"children":4090},"Locking (LCK)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F01.index",[4091,4092,4096,4100,4104,4108,4112,4116,4120,4124,4128,4132,4136],{"title":4087,"path":4088,"stem":4089},{"title":4093,"path":4094,"stem":4095},"LCK00-J. Use private final lock objects to synchronize classes that may interact with untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F02.lck00-j",{"title":4097,"path":4098,"stem":4099},"LCK01-J. Do not synchronize on objects that may be reused","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F03.lck01-j",{"title":4101,"path":4102,"stem":4103},"LCK02-J. Do not synchronize on the class object returned by getClass()","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F04.lck02-j",{"title":4105,"path":4106,"stem":4107},"LCK03-J. Do not synchronize on the intrinsic locks of high-level concurrency objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F05.lck03-j",{"title":4109,"path":4110,"stem":4111},"LCK04-J. Do not synchronize on a collection view if the backing collection is accessible","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F06.lck04-j",{"title":4113,"path":4114,"stem":4115},"LCK05-J. Synchronize access to static fields that can be modified by untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F07.lck05-j",{"title":4117,"path":4118,"stem":4119},"LCK06-J. Do not use an instance lock to protect shared static data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F08.lck06-j",{"title":4121,"path":4122,"stem":4123},"LCK07-J. Avoid deadlock by requesting and releasing locks in the same order","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F09.lck07-j",{"title":4125,"path":4126,"stem":4127},"LCK08-J. Ensure actively held locks are released on exceptional conditions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F10.lck08-j",{"title":4129,"path":4130,"stem":4131},"LCK09-J. Do not perform operations that can block while holding a lock","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F11.lck09-j",{"title":4133,"path":4134,"stem":4135},"LCK10-J. Use a correct form of the double-checked locking idiom","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F12.lck10-j",{"title":4137,"path":4138,"stem":4139},"LCK11-J. Avoid client-side locking when using classes that do not commit to their locking strategy","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F13.lck11-j",{"title":4141,"path":4142,"stem":4143,"children":4144},"Methods (MET)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F01.index",[4145,4146,4150,4154,4158,4162,4166,4170,4174,4175,4176,4177,4181,4185,4189],{"title":4141,"path":4142,"stem":4143},{"title":4147,"path":4148,"stem":4149},"MET00-J. Validate method arguments","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F02.met00-j",{"title":4151,"path":4152,"stem":4153},"MET01-J. Never use assertions to validate method arguments","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F03.met01-j",{"title":4155,"path":4156,"stem":4157},"MET02-J. Do not use deprecated or obsolete classes or methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F04.met02-j",{"title":4159,"path":4160,"stem":4161},"MET03-J. Methods that perform a security check must be declared private or final","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F05.met03-j",{"title":4163,"path":4164,"stem":4165},"MET04-J. Do not increase the accessibility of overridden or hidden methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F06.met04-j",{"title":4167,"path":4168,"stem":4169},"MET05-J. Ensure that constructors do not call overridable methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F07.met05-j",{"title":4171,"path":4172,"stem":4173},"MET06-J. Do not invoke overridable methods in clone()","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F08.met06-j",{"title":3642,"path":3585,"stem":3643},{"title":30,"path":3636,"stem":3638},{"title":3645,"path":3598,"stem":3646},{"title":4178,"path":4179,"stem":4180},"MET10-J. Follow the general contract when implementing the compareTo() method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F12.met10-j",{"title":4182,"path":4183,"stem":4184},"MET11-J. Ensure that keys used in comparison operations are immutable","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F13.met11-j",{"title":4186,"path":4187,"stem":4188},"MET12-J. Do not use finalizers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet12-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F14.met12-j",{"title":4190,"path":4191,"stem":4192},"MET13-J. Do not assume that reassigning method arguments modifies the calling environment","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet13-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F15.met13-j",{"title":4194,"path":4195,"stem":4196,"children":4197},"Miscellaneous (MSC)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F01.index",[4198,4199,4203,4207,4211,4215,4219,4223,4227,4231,4235,4239,4243],{"title":4194,"path":4195,"stem":4196},{"title":4200,"path":4201,"stem":4202},"MSC00-J. Use SSLSocket rather than Socket for secure data exchange","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F02.msc00-j",{"title":4204,"path":4205,"stem":4206},"MSC01-J. Do not use an empty infinite loop","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F03.msc01-j",{"title":4208,"path":4209,"stem":4210},"MSC02-J. Generate strong random numbers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F04.msc02-j",{"title":4212,"path":4213,"stem":4214},"MSC03-J. Never hard code sensitive information","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F05.msc03-j",{"title":4216,"path":4217,"stem":4218},"MSC04-J. Do not leak memory","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F06.msc04-j",{"title":4220,"path":4221,"stem":4222},"MSC05-J. Do not exhaust heap space","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F07.msc05-j",{"title":4224,"path":4225,"stem":4226},"MSC06-J. Do not modify the underlying collection when an iteration is in progress","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F08.msc06-j",{"title":4228,"path":4229,"stem":4230},"MSC07-J. Prevent multiple instantiations of singleton objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F09.msc07-j",{"title":4232,"path":4233,"stem":4234},"MSC08-J. Do not store nonserializable objects as attributes in an HTTP session","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F10.msc08-j",{"title":4236,"path":4237,"stem":4238},"MSC09-J. For OAuth, ensure (a) [relying party receiving user's ID in last step] is same as (b) [relying party the access token was granted to].","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F11.msc09-j",{"title":4240,"path":4241,"stem":4242},"MSC10-J. Do not use OAuth 2.0 implicit grant (unmodified) for authentication","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F12.msc10-j",{"title":4244,"path":4245,"stem":4246},"MSC11-J. Do not let session information leak within a servlet","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmiscellaneous-msc\u002Fmsc11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F12.miscellaneous-msc\u002F13.msc11-j",{"title":4248,"path":4249,"stem":4250,"children":4251},"Numeric Types and Operations (NUM)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F01.index",[4252,4253,4257,4261,4265,4269,4273,4277,4281,4285,4289,4293,4297,4301],{"title":4248,"path":4249,"stem":4250},{"title":4254,"path":4255,"stem":4256},"NUM00-J. Detect or prevent integer overflow","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F02.num00-j",{"title":4258,"path":4259,"stem":4260},"NUM01-J. Do not perform bitwise and arithmetic operations on the same data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F03.num01-j",{"title":4262,"path":4263,"stem":4264},"NUM02-J. Ensure that division and remainder operations do not result in divide-by-zero errors","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F04.num02-j",{"title":4266,"path":4267,"stem":4268},"NUM03-J. Use integer types that can fully represent the possible range of unsigned data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F05.num03-j",{"title":4270,"path":4271,"stem":4272},"NUM04-J. Do not use floating-point numbers if precise computation is required","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F06.num04-j",{"title":4274,"path":4275,"stem":4276},"NUM07-J. Do not attempt comparisons with NaN","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F07.num07-j",{"title":4278,"path":4279,"stem":4280},"NUM08-J. Check floating-point inputs for exceptional values","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F08.num08-j",{"title":4282,"path":4283,"stem":4284},"NUM09-J. Do not use floating-point variables as loop counters","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F09.num09-j",{"title":4286,"path":4287,"stem":4288},"NUM10-J. Do not construct BigDecimal objects from floating-point literals","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F10.num10-j",{"title":4290,"path":4291,"stem":4292},"NUM11-J. Do not compare or inspect the string representation of floating-point values","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F11.num11-j",{"title":4294,"path":4295,"stem":4296},"NUM12-J. Ensure conversions of numeric types to narrower types do not result in lost or misinterpreted data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum12-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F12.num12-j",{"title":4298,"path":4299,"stem":4300},"NUM13-J. Avoid loss of precision when converting primitive integers to floating-point","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum13-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F13.num13-j",{"title":4302,"path":4303,"stem":4304},"NUM14-J. Use shift operators correctly","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum14-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F14.num14-j",{"title":4306,"path":4307,"stem":4308,"children":4309},"Object Orientation (OBJ)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F01.index",[4310,4311,4315,4319,4323,4327,4331,4335,4339,4343,4347,4351,4355,4359,4363],{"title":4306,"path":4307,"stem":4308},{"title":4312,"path":4313,"stem":4314},"OBJ01-J. Limit accessibility of fields","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F02.obj01-j",{"title":4316,"path":4317,"stem":4318},"OBJ02-J. Preserve dependencies in subclasses when changing superclasses","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F03.obj02-j",{"title":4320,"path":4321,"stem":4322},"OBJ03-J. Prevent heap pollution","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F04.obj03-j",{"title":4324,"path":4325,"stem":4326},"OBJ04-J. Provide mutable classes with copy functionality to safely allow passing instances to untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F05.obj04-j",{"title":4328,"path":4329,"stem":4330},"OBJ05-J. Do not return references to private mutable class members","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F06.obj05-j",{"title":4332,"path":4333,"stem":4334},"OBJ06-J. Defensively copy mutable inputs and mutable internal components","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F07.obj06-j",{"title":4336,"path":4337,"stem":4338},"OBJ07-J. Sensitive classes must not let themselves be copied","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F08.obj07-j",{"title":4340,"path":4341,"stem":4342},"OBJ08-J. Do not expose private members of an outer class from within a nested class","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F09.obj08-j",{"title":4344,"path":4345,"stem":4346},"OBJ09-J. Compare classes and not class names","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F10.obj09-j",{"title":4348,"path":4349,"stem":4350},"OBJ10-J. Do not use public static nonfinal fields","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F11.obj10-j",{"title":4352,"path":4353,"stem":4354},"OBJ11-J. Be wary of letting constructors throw exceptions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F12.obj11-j",{"title":4356,"path":4357,"stem":4358},"OBJ12-J. Respect object-based annotations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj12-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F13.obj12-j",{"title":4360,"path":4361,"stem":4362},"OBJ13-J. Ensure that references to mutable objects are not exposed","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj13-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F14.obj13-j",{"title":4364,"path":4365,"stem":4366},"OBJ14-J. Do not use an object that has been freed.","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fobject-orientation-obj\u002Fobj14-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F14.object-orientation-obj\u002F15.obj14-j",{"title":4368,"path":4369,"stem":4370,"children":4371},"Platform Security (SEC)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F01.index",[4372,4373,4377,4381,4385,4389,4393,4397,4401,4405,4409,4413],{"title":4368,"path":4369,"stem":4370},{"title":4374,"path":4375,"stem":4376},"SEC00-J. Do not allow privileged blocks to leak sensitive information across a trust boundary","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F02.sec00-j",{"title":4378,"path":4379,"stem":4380},"SEC01-J. Do not allow tainted variables in privileged blocks","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F03.sec01-j",{"title":4382,"path":4383,"stem":4384},"SEC02-J. Do not base security checks on untrusted sources","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F04.sec02-j",{"title":4386,"path":4387,"stem":4388},"SEC03-J. Do not load trusted classes after allowing untrusted code to load arbitrary classes","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F05.sec03-j",{"title":4390,"path":4391,"stem":4392},"SEC04-J. Protect sensitive operations with security manager checks","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F06.sec04-j",{"title":4394,"path":4395,"stem":4396},"SEC05-J. Do not use reflection to increase accessibility of classes, methods, or fields","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F07.sec05-j",{"title":4398,"path":4399,"stem":4400},"SEC06-J. Do not rely on the default automatic signature verification provided by URLClassLoader and java.util.jar","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F08.sec06-j",{"title":4402,"path":4403,"stem":4404},"SEC07-J. Call the superclass's getPermissions() method when writing a custom class loader","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F09.sec07-j",{"title":4406,"path":4407,"stem":4408},"SEC08-J Trusted code must discard or clean any arguments provided by untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F10.sec08-j",{"title":4410,"path":4411,"stem":4412},"SEC09-J Never leak the results of certain standard API methods from trusted code to untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F11.sec09-j",{"title":4414,"path":4415,"stem":4416},"SEC10-J Never permit untrusted code to invoke any API that may (possibly transitively) invoke the reflection APIs","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fplatform-security-sec\u002Fsec10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F15.platform-security-sec\u002F12.sec10-j",{"title":4418,"path":4419,"stem":4420,"children":4421},"Runtime Environment (ENV)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F1.index",[4422,4423,4427,4431,4435,4445,4449,4453],{"title":4418,"path":4419,"stem":4420},{"title":4424,"path":4425,"stem":4426},"ENV00-J. Do not sign code that performs only unprivileged operations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F2.env00-j",{"title":4428,"path":4429,"stem":4430},"ENV01-J. Place all security-sensitive code in a single JAR and sign and seal it","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F3.env01-j",{"title":4432,"path":4433,"stem":4434},"ENV02-J. Do not trust the values of environment variables","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F4.env02-j",{"title":4436,"path":4437,"stem":4438,"children":4439},"ENV03-J. Do not grant dangerous combinations of permissions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F5.env03-j\u002F1.index",[4440,4441],{"title":4436,"path":4437,"stem":4438},{"title":4442,"path":4443,"stem":4444},"DUMMY ENV03-J","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv03-j\u002Fdummy-env03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F5.env03-j\u002F2.dummy-env03-j",{"title":4446,"path":4447,"stem":4448},"ENV04-J. Do not disable bytecode verification","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F6.env04-j",{"title":4450,"path":4451,"stem":4452},"ENV05-J. Do not deploy an application that can be remotely monitored","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F7.env05-j",{"title":4454,"path":4455,"stem":4456},"ENV06-J. Production code must not contain debugging entry points","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fruntime-environment-env\u002Fenv06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F16.runtime-environment-env\u002F8.env06-j",{"title":4458,"path":4459,"stem":4460,"children":4461},"Serialization (SER)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F01.index",[4462,4463,4467,4471,4475,4479,4483,4487,4491,4495,4499,4503,4507,4511],{"title":4458,"path":4459,"stem":4460},{"title":4464,"path":4465,"stem":4466},"SER00-J. Enable serialization compatibility during class evolution","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F02.ser00-j",{"title":4468,"path":4469,"stem":4470},"SER01-J. Do not deviate from the proper signatures of serialization methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F03.ser01-j",{"title":4472,"path":4473,"stem":4474},"SER02-J. Sign then seal objects before sending them outside a trust boundary","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F04.ser02-j",{"title":4476,"path":4477,"stem":4478},"SER03-J. Do not serialize unencrypted sensitive data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F05.ser03-j",{"title":4480,"path":4481,"stem":4482},"SER04-J. Do not allow serialization and deserialization to bypass the security manager","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F06.ser04-j",{"title":4484,"path":4485,"stem":4486},"SER05-J. Do not serialize instances of inner classes","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F07.ser05-j",{"title":4488,"path":4489,"stem":4490},"SER06-J. Make defensive copies of private mutable components during deserialization","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser06-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F08.ser06-j",{"title":4492,"path":4493,"stem":4494},"SER07-J. Do not use the default serialized form for classes with implementation-defined invariants","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F09.ser07-j",{"title":4496,"path":4497,"stem":4498},"SER08-J. Minimize privileges before deserializing from a privileged context","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F10.ser08-j",{"title":4500,"path":4501,"stem":4502},"SER09-J. Do not invoke overridable methods from the readObject() method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F11.ser09-j",{"title":4504,"path":4505,"stem":4506},"SER10-J. Avoid memory and resource leaks during serialization","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser10-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F12.ser10-j",{"title":4508,"path":4509,"stem":4510},"SER11-J. Prevent overwriting of externalizable objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser11-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F13.ser11-j",{"title":4512,"path":4513,"stem":4514},"SER12-J. Prevent deserialization of untrusted data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fserialization-ser\u002Fser12-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F17.serialization-ser\u002F14.ser12-j",{"title":4516,"path":4517,"stem":4518,"children":4519},"Thread APIs (THI)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F1.index",[4520,4521,4525,4529,4533,4537,4541],{"title":4516,"path":4517,"stem":4518},{"title":4522,"path":4523,"stem":4524},"THI00-J. Do not invoke Thread.run()","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F2.thi00-j",{"title":4526,"path":4527,"stem":4528},"THI01-J. Do not invoke ThreadGroup methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F3.thi01-j",{"title":4530,"path":4531,"stem":4532},"THI02-J. Notify all waiting threads rather than a single thread","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F4.thi02-j",{"title":4534,"path":4535,"stem":4536},"THI03-J. Always invoke wait() and await() methods inside a loop","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F5.thi03-j",{"title":4538,"path":4539,"stem":4540},"THI04-J. Ensure that threads performing blocking operations can be terminated","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F6.thi04-j",{"title":4542,"path":4543,"stem":4544},"THI05-J. Do not use Thread.stop() to terminate threads","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-apis-thi\u002Fthi05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F18.thread-apis-thi\u002F7.thi05-j",{"title":4546,"path":4547,"stem":4548,"children":4549},"Thread Pools (TPS)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F1.index",[4550,4551,4555,4559,4563,4567],{"title":4546,"path":4547,"stem":4548},{"title":4552,"path":4553,"stem":4554},"TPS00-J. Use thread pools to enable graceful degradation of service during traffic bursts","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps\u002Ftps00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F2.tps00-j",{"title":4556,"path":4557,"stem":4558},"TPS01-J. Do not execute interdependent tasks in a bounded thread pool","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps\u002Ftps01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F3.tps01-j",{"title":4560,"path":4561,"stem":4562},"TPS02-J. Ensure that tasks submitted to a thread pool are interruptible","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps\u002Ftps02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F4.tps02-j",{"title":4564,"path":4565,"stem":4566},"TPS03-J. Ensure that tasks executing in a thread pool do not fail silently","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps\u002Ftps03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F5.tps03-j",{"title":4568,"path":4569,"stem":4570},"TPS04-J. Ensure ThreadLocal variables are reinitialized when using thread pools","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-pools-tps\u002Ftps04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F19.thread-pools-tps\u002F6.tps04-j",{"title":4572,"path":4573,"stem":4574,"children":4575},"Thread-Safety Miscellaneous (TSM)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-safety-miscellaneous-tsm","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F20.thread-safety-miscellaneous-tsm\u002F1.index",[4576,4577,4581,4585,4589],{"title":4572,"path":4573,"stem":4574},{"title":4578,"path":4579,"stem":4580},"TSM00-J. Do not override thread-safe methods with methods that are not thread-safe","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-safety-miscellaneous-tsm\u002Ftsm00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F20.thread-safety-miscellaneous-tsm\u002F2.tsm00-j",{"title":4582,"path":4583,"stem":4584},"TSM01-J. Do not let the this reference escape during object construction","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-safety-miscellaneous-tsm\u002Ftsm01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F20.thread-safety-miscellaneous-tsm\u002F3.tsm01-j",{"title":4586,"path":4587,"stem":4588},"TSM02-J. Do not use background threads during class initialization","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-safety-miscellaneous-tsm\u002Ftsm02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F20.thread-safety-miscellaneous-tsm\u002F4.tsm02-j",{"title":4590,"path":4591,"stem":4592},"TSM03-J. Do not publish partially initialized objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fthread-safety-miscellaneous-tsm\u002Ftsm03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F20.thread-safety-miscellaneous-tsm\u002F5.tsm03-j",{"title":4594,"path":4595,"stem":4596,"children":4597},"Visibility and Atomicity (VNA)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F1.index",[4598,4599,4603,4607,4611,4615,4619],{"title":4594,"path":4595,"stem":4596},{"title":4600,"path":4601,"stem":4602},"VNA00-J. Ensure visibility when accessing shared primitive variables","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna00-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F2.vna00-j",{"title":4604,"path":4605,"stem":4606},"VNA01-J. Ensure visibility of shared references to immutable objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna01-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F3.vna01-j",{"title":4608,"path":4609,"stem":4610},"VNA02-J. Ensure that compound operations on shared variables are atomic","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna02-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F4.vna02-j",{"title":4612,"path":4613,"stem":4614},"VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna03-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F5.vna03-j",{"title":4616,"path":4617,"stem":4618},"VNA04-J. Ensure that calls to chained methods are atomic","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna04-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F6.vna04-j",{"title":4620,"path":4621,"stem":4622},"VNA05-J. Ensure atomicity when reading and writing 64-bit values","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna05-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F7.vna05-j",{"title":4624,"path":4625,"stem":4626,"children":4627},"Recommendations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F01.index",[4628,4629,4642,4660,4713,4738,4767,4788,4821,4854,4915,4940,4981],{"title":4624,"path":4625,"stem":4626},{"title":3805,"path":4630,"stem":4631,"children":4632},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fcharacters-and-strings-str","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F02.characters-and-strings-str\u002F1.index",[4633,4634,4638],{"title":3805,"path":4630,"stem":4631},{"title":4635,"path":4636,"stem":4637},"STR50-J. Use the appropriate method for counting characters in a string","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F02.characters-and-strings-str\u002F2.str50-j",{"title":4639,"path":4640,"stem":4641},"STR51-J. Use the charset encoder and decoder classes when more control over the encoding process is required","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fcharacters-and-strings-str\u002Fstr51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F02.characters-and-strings-str\u002F3.str51-j",{"title":4643,"path":4644,"stem":4645,"children":4646},"Concurrency (CON)","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fconcurrency-con","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F03.concurrency-con\u002F1.index",[4647,4648,4652,4656],{"title":4643,"path":4644,"stem":4645},{"title":4649,"path":4650,"stem":4651},"CON50-J. Do not assume that declaring a reference volatile guarantees safe publication of the members of the referenced object","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fconcurrency-con\u002Fcon50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F03.concurrency-con\u002F2.con50-j",{"title":4653,"path":4654,"stem":4655},"CON51-J. Do not assume that the sleep(), yield(), or getState() methods provide synchronization semantics","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fconcurrency-con\u002Fcon51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F03.concurrency-con\u002F3.con51-j",{"title":4657,"path":4658,"stem":4659},"CON52-J. Document thread-safety and use annotations where applicable","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fconcurrency-con\u002Fcon52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F03.concurrency-con\u002F4.con52-j",{"title":3831,"path":4661,"stem":4662,"children":4663},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F01.index",[4664,4665,4669,4673,4677,4681,4685,4689,4693,4697,4701,4705,4709],{"title":3831,"path":4661,"stem":4662},{"title":4666,"path":4667,"stem":4668},"DCL50-J. Use visually distinct identifiers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F02.dcl50-j",{"title":4670,"path":4671,"stem":4672},"DCL51-J. Do not shadow or obscure identifiers in subscopes","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F03.dcl51-j",{"title":4674,"path":4675,"stem":4676},"DCL52-J. Do not declare more than one variable per declaration","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F04.dcl52-j",{"title":4678,"path":4679,"stem":4680},"DCL53-J. Minimize the scope of variables","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F05.dcl53-j",{"title":4682,"path":4683,"stem":4684},"DCL54-J. Use meaningful symbolic constants to represent literal values in program logic","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F06.dcl54-j",{"title":4686,"path":4687,"stem":4688},"DCL55-J. Properly encode relationships in constant definitions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F07.dcl55-j",{"title":4690,"path":4691,"stem":4692},"DCL56-J. Do not attach significance to the ordinal associated with an enum","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F08.dcl56-j",{"title":4694,"path":4695,"stem":4696},"DCL57-J. Avoid ambiguous overloading of variable arity methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl57-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F09.dcl57-j",{"title":4698,"path":4699,"stem":4700},"DCL58-J. Enable compile-time type checking of variable arity parameter types","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl58-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F10.dcl58-j",{"title":4702,"path":4703,"stem":4704},"DCL59-J. Do not apply public final to constants whose value might change in later releases","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl59-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F11.dcl59-j",{"title":4706,"path":4707,"stem":4708},"DCL60-J. Avoid cyclic dependencies between packages","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl60-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F12.dcl60-j",{"title":4710,"path":4711,"stem":4712},"DCL61-J. Do not use raw types","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fdeclarations-and-initialization-dcl\u002Fdcl61-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F04.declarations-and-initialization-dcl\u002F13.dcl61-j",{"title":3849,"path":4714,"stem":4715,"children":4716},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F1.index",[4717,4718,4722,4726,4730,4734],{"title":3849,"path":4714,"stem":4715},{"title":4719,"path":4720,"stem":4721},"ERR50-J. Use exceptions only for exceptional conditions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err\u002Ferr50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F2.err50-j",{"title":4723,"path":4724,"stem":4725},"ERR51-J. Prefer user-defined exceptions over more general exception types","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err\u002Ferr51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F3.err51-j",{"title":4727,"path":4728,"stem":4729},"ERR52-J. Avoid in-band error indicators","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err\u002Ferr52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F4.err52-j",{"title":4731,"path":4732,"stem":4733},"ERR53-J. Try to gracefully recover from system errors","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err\u002Ferr53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F5.err53-j",{"title":4735,"path":4736,"stem":4737},"ERR54-J. Use a try-with-resources statement to safely handle closeable resources","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexceptional-behavior-err\u002Ferr54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F05.exceptional-behavior-err\u002F6.err54-j",{"title":3895,"path":4739,"stem":4740,"children":4741},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F1.index",[4742,4743,4747,4751,4755,4759,4763],{"title":3895,"path":4739,"stem":4740},{"title":4744,"path":4745,"stem":4746},"EXP50-J. Do not confuse abstract object equality with reference equality","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F2.exp50-j",{"title":4748,"path":4749,"stem":4750},"EXP51-J. Do not perform assignments in conditional expressions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F3.exp51-j",{"title":4752,"path":4753,"stem":4754},"EXP52-J. Use braces for the body of an if, for, or while statement","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F4.exp52-j",{"title":4756,"path":4757,"stem":4758},"EXP53-J. Use parentheses for precedence of operation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F5.exp53-j",{"title":4760,"path":4761,"stem":4762},"EXP54-J. Understand the differences between bitwise and logical operators","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F6.exp54-j",{"title":4764,"path":4765,"stem":4766},"EXP55-J. Use the same type for the second and third operands in conditional expressions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fexpressions-exp\u002Fexp55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F06.expressions-exp\u002F7.exp55-j",{"title":3933,"path":4768,"stem":4769,"children":4770},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-output-fio","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F07.input-output-fio\u002F1.index",[4771,4772,4776,4780,4784],{"title":3933,"path":4768,"stem":4769},{"title":4773,"path":4774,"stem":4775},"FIO50-J. Do not make assumptions about file creation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-output-fio\u002Ffio50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F07.input-output-fio\u002F2.fio50-j",{"title":4777,"path":4778,"stem":4779},"FIO51-J. Identify files using multiple file attributes","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-output-fio\u002Ffio51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F07.input-output-fio\u002F3.fio51-j",{"title":4781,"path":4782,"stem":4783},"FIO52-J. Do not store unencrypted sensitive information on the client side","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-output-fio\u002Ffio52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F07.input-output-fio\u002F4.fio52-j",{"title":4785,"path":4786,"stem":4787},"FIO53-J. Use the serialization methods writeUnshared() and readUnshared() with care","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-output-fio\u002Ffio53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F07.input-output-fio\u002F5.fio53-j",{"title":4007,"path":4789,"stem":4790,"children":4791},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F1.index",[4792,4793,4797,4801,4805,4809,4813,4817],{"title":4007,"path":4789,"stem":4790},{"title":4794,"path":4795,"stem":4796},"IDS50-J. Use conservative file naming conventions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F2.ids50-j",{"title":4798,"path":4799,"stem":4800},"IDS51-J. Properly encode or escape output","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F3.ids51-j",{"title":4802,"path":4803,"stem":4804},"IDS52-J. Prevent code injection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F4.ids52-j",{"title":4806,"path":4807,"stem":4808},"IDS53-J. Prevent XPath Injection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F5.ids53-j",{"title":4810,"path":4811,"stem":4812},"IDS54-J. Prevent LDAP injection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F6.ids54-j",{"title":4814,"path":4815,"stem":4816},"IDS55-J. Understand how escape characters are interpreted when strings are loaded","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F7.ids55-j",{"title":4818,"path":4819,"stem":4820},"IDS56-J. Prevent arbitrary file upload","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Finput-validation-and-data-sanitization-ids\u002Fids56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F08.input-validation-and-data-sanitization-ids\u002F8.ids56-j",{"title":4141,"path":4822,"stem":4823,"children":4824},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F1.index",[4825,4826,4830,4834,4838,4842,4846,4850],{"title":4141,"path":4822,"stem":4823},{"title":4827,"path":4828,"stem":4829},"MET50-J. Avoid ambiguous or confusing uses of overloading","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F2.met50-j",{"title":4831,"path":4832,"stem":4833},"MET51-J. Do not use overloaded methods to differentiate between runtime types","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F3.met51-j",{"title":4835,"path":4836,"stem":4837},"MET52-J. Do not use the clone() method to copy untrusted method parameters","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F4.met52-j",{"title":4839,"path":4840,"stem":4841},"MET53-J. Ensure that the clone() method calls super.clone()","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F5.met53-j",{"title":4843,"path":4844,"stem":4845},"MET54-J. Always provide feedback about the resulting value of a method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F6.met54-j",{"title":4847,"path":4848,"stem":4849},"MET55-J. Return an empty array or collection instead of a null value for methods that return an array or collection","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F7.met55-j",{"title":4851,"path":4852,"stem":4853},"MET56-J. Do not use Object.equals() to compare cryptographic keys","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmethods-met\u002Fmet56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F09.methods-met\u002F8.met56-j",{"title":4194,"path":4855,"stem":4856,"children":4857},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F01.index",[4858,4859,4863,4867,4871,4875,4879,4883,4887,4891,4895,4899,4903,4907,4911],{"title":4194,"path":4855,"stem":4856},{"title":4860,"path":4861,"stem":4862},"MSC50-J. Minimize the scope of the @SuppressWarnings annotation","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F02.msc50-j",{"title":4864,"path":4865,"stem":4866},"MSC51-J. Do not place a semicolon immediately following an if, for, or while condition","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F03.msc51-j",{"title":4868,"path":4869,"stem":4870},"MSC52-J. Finish every set of statements associated with a case label with a break statement","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F04.msc52-j",{"title":4872,"path":4873,"stem":4874},"MSC53-J. Carefully design interfaces before releasing them","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F05.msc53-j",{"title":4876,"path":4877,"stem":4878},"MSC54-J. Avoid inadvertent wrapping of loop counters","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F06.msc54-j",{"title":4880,"path":4881,"stem":4882},"MSC55-J. Use comments consistently and in a readable fashion","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F07.msc55-j",{"title":4884,"path":4885,"stem":4886},"MSC56-J. Detect and remove superfluous code and values","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F08.msc56-j",{"title":4888,"path":4889,"stem":4890},"MSC57-J. Strive for logical completeness","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc57-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F09.msc57-j",{"title":4892,"path":4893,"stem":4894},"MSC58-J. Prefer using iterators over enumerations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc58-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F10.msc58-j",{"title":4896,"path":4897,"stem":4898},"MSC59-J. Limit the lifetime of sensitive data","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc59-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F11.msc59-j",{"title":4900,"path":4901,"stem":4902},"MSC60-J. Do not use assertions to verify the absence of runtime errors","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc60-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F12.msc60-j",{"title":4904,"path":4905,"stem":4906},"MSC61-J. Do not use insecure or weak cryptographic algorithms","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc61-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F13.msc61-j",{"title":4908,"path":4909,"stem":4910},"MSC62-J. Store passwords using a hash function","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc62-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F14.msc62-j",{"title":4912,"path":4913,"stem":4914},"MSC63-J. Ensure that SecureRandom is properly seeded","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fmiscellaneous-msc\u002Fmsc63-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F10.miscellaneous-msc\u002F15.msc63-j",{"title":4248,"path":4916,"stem":4917,"children":4918},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F1.index",[4919,4920,4924,4928,4932,4936],{"title":4248,"path":4916,"stem":4917},{"title":4921,"path":4922,"stem":4923},"NUM50-J. Convert integers to floating point for floating-point operations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num\u002Fnum50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F2.num50-j",{"title":4925,"path":4926,"stem":4927},"NUM51-J. Do not assume that the remainder operator always returns a nonnegative result for integral operands","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num\u002Fnum51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F3.num51-j",{"title":4929,"path":4930,"stem":4931},"NUM52-J. Be aware of numeric promotion behavior","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num\u002Fnum52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F4.num52-j",{"title":4933,"path":4934,"stem":4935},"NUM53-J. Use the strictfp modifier for floating-point calculation consistency across platforms","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num\u002Fnum53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F5.num53-j",{"title":4937,"path":4938,"stem":4939},"NUM54-J. Do not use denormalized numbers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fnumeric-types-and-operations-num\u002Fnum54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F11.numeric-types-and-operations-num\u002F6.num54-j",{"title":4306,"path":4941,"stem":4942,"children":4943},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F01.index",[4944,4945,4949,4953,4957,4961,4965,4969,4973,4977],{"title":4306,"path":4941,"stem":4942},{"title":4946,"path":4947,"stem":4948},"OBJ50-J. Never confuse the immutability of a reference with that of the referenced object","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F02.obj50-j",{"title":4950,"path":4951,"stem":4952},"OBJ51-J. Minimize the accessibility of classes and their members","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F03.obj51-j",{"title":4954,"path":4955,"stem":4956},"OBJ52-J. Write garbage-collection-friendly code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F04.obj52-j",{"title":4958,"path":4959,"stem":4960},"OBJ53-J. Do not use direct buffers for short-lived, infrequently used objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F05.obj53-j",{"title":4962,"path":4963,"stem":4964},"OBJ54-J. Do not attempt to help the garbage collector by setting local reference variables to null","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F06.obj54-j",{"title":4966,"path":4967,"stem":4968},"OBJ55-J. Remove short-lived objects from long-lived container objects","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F07.obj55-j",{"title":4970,"path":4971,"stem":4972},"OBJ56-J. Provide sensitive mutable classes with unmodifiable wrappers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F08.obj56-j",{"title":4974,"path":4975,"stem":4976},"OBJ57-J. Do not rely on methods that can be overridden by untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj57-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F09.obj57-j",{"title":4978,"path":4979,"stem":4980},"OBJ58-J. Limit the extensibility of classes and methods with invariants","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fobject-orientation-obj\u002Fobj58-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F12.object-orientation-obj\u002F10.obj58-j",{"title":4368,"path":4982,"stem":4983,"children":4984},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F01.index",[4985,4986,4990,4994,4998,5002,5006,5010,5014,5018],{"title":4368,"path":4982,"stem":4983},{"title":4987,"path":4988,"stem":4989},"SEC50-J. Avoid granting excess privileges","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec50-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F02.sec50-j",{"title":4991,"path":4992,"stem":4993},"SEC51-J. Minimize privileged code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec51-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F03.sec51-j",{"title":4995,"path":4996,"stem":4997},"SEC52-J. Do not expose methods that use reduced-security checks to untrusted code","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec52-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F04.sec52-j",{"title":4999,"path":5000,"stem":5001},"SEC53-J. Define custom security permissions for fine-grained security","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec53-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F05.sec53-j",{"title":5003,"path":5004,"stem":5005},"SEC54-J. Create a secure sandbox using a security manager","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec54-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F06.sec54-j",{"title":5007,"path":5008,"stem":5009},"SEC55-J. Ensure that security-sensitive methods are called with validated arguments","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec55-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F07.sec55-j",{"title":5011,"path":5012,"stem":5013},"SEC56-J. Do not serialize direct handles to system resources","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec56-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F08.sec56-j",{"title":5015,"path":5016,"stem":5017},"SEC57-J. Do not let untrusted code misuse privileges of callback methods","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec57-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F09.sec57-j",{"title":5019,"path":5020,"stem":5021},"SEC58-J. Deserialization methods should not perform potentially dangerous operations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations\u002Fplatform-security-sec\u002Fsec58-j","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F13.platform-security-sec\u002F10.sec58-j",{"title":5023,"path":5024,"stem":5025,"children":5026},"Back Matter","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F1.index",[5027,5028,5032,5036,5040,5044,5165,5190],{"title":5023,"path":5024,"stem":5025},{"title":5029,"path":5030,"stem":5031},"Rec. AA. References","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frec-aa-references","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F2.rec-aa-references",{"title":5033,"path":5034,"stem":5035},"Rec. BB. Definitions","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frec-bb-definitions","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F3.rec-bb-definitions",{"title":5037,"path":5038,"stem":5039},"Rule AA. References","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F4.rule-aa-references",{"title":5041,"path":5042,"stem":5043},"Rule BB. Glossary","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F5.rule-bb-glossary",{"title":5045,"path":5046,"stem":5047,"children":5048},"Rule or Rec. CC. Analyzers","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F01.index",[5049,5050,5052,5056,5060,5064,5068,5072,5076,5080,5084,5088,5092,5096,5100,5104,5107,5111,5115,5119,5123,5127,5131,5135,5137,5141,5145,5149,5153,5157,5161],{"title":5045,"path":5046,"stem":5047},{"title":3250,"path":3249,"stem":5051},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F02.codesonar",{"title":5053,"path":5054,"stem":5055},"CodeSonar_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcodesonar_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F03.codesonar_v",{"title":5057,"path":5058,"stem":5059},"Coverity","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcoverity","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F04.coverity",{"title":5061,"path":5062,"stem":5063},"Coverity_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcoverity_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F05.coverity_v",{"title":5065,"path":5066,"stem":5067},"Eclipse","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Feclipse","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F06.eclipse",{"title":5069,"path":5070,"stem":5071},"Eclipse_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Feclipse_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F07.eclipse_v",{"title":5073,"path":5074,"stem":5075},"Error Prone","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ferror-prone","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F08.error-prone",{"title":5077,"path":5078,"stem":5079},"Error Prone_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ferror-prone_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F09.error-prone_v",{"title":5081,"path":5082,"stem":5083},"Findbugs","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ffindbugs","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F10.findbugs",{"title":5085,"path":5086,"stem":5087},"Findbugs_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ffindbugs_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F11.findbugs_v",{"title":5089,"path":5090,"stem":5091},"Fortify","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ffortify","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F12.fortify",{"title":5093,"path":5094,"stem":5095},"Fortify_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Ffortify_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F13.fortify_v",{"title":5097,"path":5098,"stem":5099},"Klocwork","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fklocwork","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F14.klocwork",{"title":5101,"path":5102,"stem":5103},"Klocwork_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fklocwork_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F15.klocwork_v",{"title":5105,"path":3304,"stem":5106},"Parasoft","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F16.parasoft",{"title":5108,"path":5109,"stem":5110},"Parasoft_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fparasoft_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F17.parasoft_v",{"title":5112,"path":5113,"stem":5114},"Pmd","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fpmd","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F18.pmd",{"title":5116,"path":5117,"stem":5118},"Pmd_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fpmd_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F19.pmd_v",{"title":5120,"path":5121,"stem":5122},"PVS-Studio","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fpvs-studio","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F20.pvs-studio",{"title":5124,"path":5125,"stem":5126},"PVS-Studio_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fpvs-studio_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F21.pvs-studio_v",{"title":5128,"path":5129,"stem":5130},"Security Reviewer - Static Reviewer","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fsecurity-reviewer-static-reviewer","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F22.security-reviewer-static-reviewer",{"title":5132,"path":5133,"stem":5134},"Security Reviewer - Static Reviewer_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fsecurity-reviewer-static-reviewer_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F23.security-reviewer-static-reviewer_v",{"title":3330,"path":3329,"stem":5136},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F24.sonarqube",{"title":5138,"path":5139,"stem":5140},"SonarQube_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fsonarqube_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F25.sonarqube_v",{"title":5142,"path":5143,"stem":5144},"SpotBugs","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fspotbugs","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F26.spotbugs",{"title":5146,"path":5147,"stem":5148},"SpotBugs_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fspotbugs_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F27.spotbugs_v",{"title":5150,"path":5151,"stem":5152},"The Checker Framework","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fthe-checker-framework","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F28.the-checker-framework",{"title":5154,"path":5155,"stem":5156},"The Checker Framework_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fthe-checker-framework_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F29.the-checker-framework_v",{"title":5158,"path":5159,"stem":5160},"ThreadSafe","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fthreadsafe","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F30.threadsafe",{"title":5162,"path":5163,"stem":5164},"ThreadSafe_V","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fthreadsafe_v","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F31.threadsafe_v",{"title":5166,"path":5167,"stem":5168,"children":5169},"Rule or Rec. DD. Related Guidelines","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F1.index",[5170,5171,5175,5179,5183,5186],{"title":5166,"path":5167,"stem":5168},{"title":5172,"path":5173,"stem":5174},"2010","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines\u002F2.2010","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F2.2010",{"title":5176,"path":5177,"stem":5178},"2013","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines\u002F3.2013","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F3.2013",{"title":5180,"path":5181,"stem":5182},"MITRE CAPEC","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines\u002Fmitre-capec","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F4.mitre-capec",{"title":3374,"path":5184,"stem":5185},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines\u002Fmitre-cwe","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F5.mitre-cwe",{"title":5187,"path":5188,"stem":5189},"SECURE CODING GUIDELINES FOR JAVA SE, VERSION 5.0","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-dd-related-guidelines\u002Fsecure-coding-guidelines-for-java-se-version-50","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F7.rule-or-rec-dd-related-guidelines\u002F6.secure-coding-guidelines-for-java-se-version-50",{"title":5191,"path":5192,"stem":5193},"Rule or Rec. EE. Risk Assessments","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-ee-risk-assessments","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F8.rule-or-rec-ee-risk-assessments",{"title":5195,"path":5196,"stem":5197,"children":5198},"Admin","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F1.index",[5199,5200,5204,5208,5212,5216],{"title":5195,"path":5196,"stem":5197},{"title":5201,"path":5202,"stem":5203},"All Guidelines with Classification","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin\u002Fall-guidelines-with-classification","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F2.all-guidelines-with-classification",{"title":5205,"path":5206,"stem":5207},"Normative Guidelines","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin\u002Fnormative-guidelines","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F3.normative-guidelines",{"title":5209,"path":5210,"stem":5211},"Tech-edit","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin\u002Ftech-edit","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F4.tech-edit",{"title":5213,"path":5214,"stem":5215},"TODO List","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin\u002Ftodo-list","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F5.todo-list",{"title":5213,"path":5214,"stem":5217},"6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F6.todo-list",1775657816249]