[{"data":1,"prerenderedAt":4209},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna02-j":28,"surround-\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna02-j":2643,"sidebar-sei-cert-oracle-coding-standard-for-java":2649},[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":2630,"extension":2631,"meta":2632,"navigation":7,"path":2639,"seo":2640,"stem":2641,"__hash__":2642},"content\u002F6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F4.vna02-j.md","VNA02-J. Ensure that compound operations on shared variables are atomic",{"type":32,"value":33,"toc":2614},"minimark",[34,38,99,111,123,128,146,288,298,310,453,467,471,482,577,589,593,599,694,697,701,710,807,817,937,958,962,980,1073,1081,1085,1088,1337,1343,1349,1352,1360,1368,1526,1538,1542,1567,1700,1753,1756,1760,1768,1921,1934,1938,1946,2070,2082,2086,2089,2149,2153,2158,2393,2396,2442,2446,2587,2590,2610],[35,36,30],"h1",{"id":37},"vna02-j-ensure-that-compound-operations-on-shared-variables-are-atomic",[39,40,41,42,46,47,50,51,54,55,54,58,54,61,54,64,54,67,54,70,54,73,54,76,79,80,83,84,89,90,79,94,98],"p",{},"Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment ( ",[43,44,45],"code",{},"++"," ), postfix or prefix decrement ( ",[43,48,49],{},"--"," ), or compound assignment operators always result in compound operations. Compound assignment expressions use operators such as ",[43,52,53],{},"*="," , ",[43,56,57],{},"\u002F=",[43,59,60],{},"%=",[43,62,63],{},"+=",[43,65,66],{},"-=",[43,68,69],{},"\u003C\u003C=",[43,71,72],{},">>=",[43,74,75],{},">>>=",[43,77,78],{},"^="," and ",[43,81,82],{},"|="," [ ",[85,86,88],"a",{"href":87},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-JLS15","JLS 2015"," ]. Compound operations on shared variables must be performed atomically to prevent ",[85,91,93],{"href":92},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary#RuleBB.Glossary-datarace","data races",[85,95,97],{"href":96},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary#RuleBB.Glossary-raceconditions","race conditions"," .",[39,100,101,102,106,107,98],{},"For information about the atomicity of a grouping of calls to independently atomic methods that belong to ",[85,103,105],{"href":104},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-bb-glossary","thread-safe"," classes, see ",[85,108,110],{"href":109},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna03-j","VNA03-J. Do not assume that a group of calls to independently atomic methods is atomic",[39,112,113,117,118,122],{},[114,115,116],"em",{},"The Java Language Specification"," also permits reads and writes of 64-bit values to be non-atomic (see rule ",[85,119,121],{"href":120},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna05-j","VNA05-J. Ensure atomicity when reading and writing 64-bit values"," ).",[124,125,127],"h2",{"id":126},"noncompliant-code-example-logical-negation","Noncompliant Code Example (Logical Negation)",[39,129,130,131,134,135,138,139,142,143,145],{},"This noncompliant code example declares a shared ",[43,132,133],{},"boolean"," ",[43,136,137],{},"flag"," variable and provides a ",[43,140,141],{},"toggle()"," method that negates the current value of ",[43,144,137],{}," :",[147,148,150],"code-block",{"quality":149},"bad",[151,152,157],"pre",{"className":153,"code":154,"language":155,"meta":156,"style":156},"language-java shiki shiki-themes github-light github-dark monokai","final class Flag {\n  private boolean flag = true;\n\n  public void toggle() {  \u002F\u002F Unsafe\n    flag = !flag;\n  }\n\n  public boolean getFlag() { \u002F\u002F Unsafe\n    return flag;\n  }\n}\n","java","",[43,158,159,179,202,208,228,242,248,253,268,277,282],{"__ignoreMap":156},[160,161,164,168,171,175],"span",{"class":162,"line":163},"line",1,[160,165,167],{"class":166},"sC2Qs","final",[160,169,170],{"class":166}," class",[160,172,174],{"class":173},"sz2Vg"," Flag",[160,176,178],{"class":177},"sMOD_"," {\n",[160,180,182,185,189,192,195,199],{"class":162,"line":181},2,[160,183,184],{"class":166},"  private",[160,186,188],{"class":187},"sq6CD"," boolean",[160,190,191],{"class":177}," flag ",[160,193,194],{"class":166},"=",[160,196,198],{"class":197},"s7F3e"," true",[160,200,201],{"class":177},";\n",[160,203,205],{"class":162,"line":204},3,[160,206,207],{"emptyLinePlaceholder":7},"\n",[160,209,211,214,217,221,224],{"class":162,"line":210},4,[160,212,213],{"class":166},"  public",[160,215,216],{"class":187}," void",[160,218,220],{"class":219},"srTi1"," toggle",[160,222,223],{"class":177},"() {  ",[160,225,227],{"class":226},"s8-w5","\u002F\u002F Unsafe\n",[160,229,231,234,236,239],{"class":162,"line":230},5,[160,232,233],{"class":177},"    flag ",[160,235,194],{"class":166},[160,237,238],{"class":166}," !",[160,240,241],{"class":177},"flag;\n",[160,243,245],{"class":162,"line":244},6,[160,246,247],{"class":177},"  }\n",[160,249,251],{"class":162,"line":250},7,[160,252,207],{"emptyLinePlaceholder":7},[160,254,256,258,260,263,266],{"class":162,"line":255},8,[160,257,213],{"class":166},[160,259,188],{"class":187},[160,261,262],{"class":219}," getFlag",[160,264,265],{"class":177},"() { ",[160,267,227],{"class":226},[160,269,271,274],{"class":162,"line":270},9,[160,272,273],{"class":166},"    return",[160,275,276],{"class":177}," flag;\n",[160,278,280],{"class":162,"line":279},10,[160,281,247],{"class":177},[160,283,285],{"class":162,"line":284},11,[160,286,287],{"class":177},"}\n",[39,289,290,291,294,295,297],{},"Execution of this code may result in a ",[85,292,293],{"href":92},"data race"," because the value of ",[43,296,137],{}," is read, negated, and written back.",[39,299,300,301,303,304,306,307,309],{},"Consider, for example, two threads that call ",[43,302,141],{}," . The expected effect of toggling ",[43,305,137],{}," twice is that it is restored to its original value. However, the following scenario leaves ",[43,308,137],{}," in the incorrect state:",[311,312,313,328],"table",{},[314,315,316],"thead",{},[317,318,319,322,324,326],"tr",{},[320,321],"th",{},[320,323],{},[320,325],{},[320,327],{},[329,330,331,346,368,386,402,417,436],"tbody",{},[317,332,333,337,340,343],{},[334,335,336],"td",{},"Time",[334,338,339],{},"flag=",[334,341,342],{},"Thread",[334,344,345],{},"Action",[317,347,348,351,354,362],{},[334,349,350],{},"1",[334,352,353],{},"true",[334,355,356,134,359],{},[114,357,358],{},"t",[360,361,350],"sub",{},[334,363,364,365,367],{},"Reads the current value of ",[43,366,137],{}," , true, into a temporary variable",[317,369,370,373,375,381],{},[334,371,372],{},"2",[334,374,353],{},[334,376,377,134,379],{},[114,378,358],{},[360,380,372],{},[334,382,364,383,385],{},[43,384,137],{}," , (still) true, into a temporary variable",[317,387,388,391,393,399],{},[334,389,390],{},"3",[334,392,353],{},[334,394,395,134,397],{},[114,396,358],{},[360,398,350],{},[334,400,401],{},"Toggles the temporary variable to false",[317,403,404,407,409,415],{},[334,405,406],{},"4",[334,408,353],{},[334,410,411,134,413],{},[114,412,358],{},[360,414,372],{},[334,416,401],{},[317,418,419,422,425,431],{},[334,420,421],{},"5",[334,423,424],{},"false",[334,426,427,134,429],{},[114,428,358],{},[360,430,350],{},[334,432,433,434],{},"Writes the temporary variable's value to ",[43,435,137],{},[317,437,438,441,443,449],{},[334,439,440],{},"6",[334,442,424],{},[334,444,445,134,447],{},[114,446,358],{},[360,448,372],{},[334,450,433,451],{},[43,452,137],{},[39,454,455,456,134,458,460,461,463,464,466],{},"As a result, the effect of the call by ",[114,457,358],{},[360,459,372],{}," is not reflected in ",[43,462,137],{}," ; the program behaves as if ",[43,465,141],{}," was called only once, not twice.",[124,468,470],{"id":469},"noncompliant-code-example-bitwise-negation","Noncompliant Code Example (Bitwise Negation)",[39,472,473,474,476,477,479,480,145],{},"The ",[43,475,141],{}," method may also use the compound assignment operator ",[43,478,78],{}," to negate the current value of ",[43,481,137],{},[147,483,484],{"quality":149},[151,485,487],{"className":153,"code":486,"language":155,"meta":156,"style":156},"final class Flag {\n  private boolean flag = true;\n\n  public void toggle() {  \u002F\u002F Unsafe\n    flag ^= true;  \u002F\u002F Same as flag = !flag;\n  }\n\n  public boolean getFlag() { \u002F\u002F Unsafe\n    return flag;\n  }\n}\n",[43,488,489,499,513,517,529,543,547,551,563,569,573],{"__ignoreMap":156},[160,490,491,493,495,497],{"class":162,"line":163},[160,492,167],{"class":166},[160,494,170],{"class":166},[160,496,174],{"class":173},[160,498,178],{"class":177},[160,500,501,503,505,507,509,511],{"class":162,"line":181},[160,502,184],{"class":166},[160,504,188],{"class":187},[160,506,191],{"class":177},[160,508,194],{"class":166},[160,510,198],{"class":197},[160,512,201],{"class":177},[160,514,515],{"class":162,"line":204},[160,516,207],{"emptyLinePlaceholder":7},[160,518,519,521,523,525,527],{"class":162,"line":210},[160,520,213],{"class":166},[160,522,216],{"class":187},[160,524,220],{"class":219},[160,526,223],{"class":177},[160,528,227],{"class":226},[160,530,531,533,535,537,540],{"class":162,"line":230},[160,532,233],{"class":177},[160,534,78],{"class":166},[160,536,198],{"class":197},[160,538,539],{"class":177},";  ",[160,541,542],{"class":226},"\u002F\u002F Same as flag = !flag;\n",[160,544,545],{"class":162,"line":244},[160,546,247],{"class":177},[160,548,549],{"class":162,"line":250},[160,550,207],{"emptyLinePlaceholder":7},[160,552,553,555,557,559,561],{"class":162,"line":255},[160,554,213],{"class":166},[160,556,188],{"class":187},[160,558,262],{"class":219},[160,560,265],{"class":177},[160,562,227],{"class":226},[160,564,565,567],{"class":162,"line":270},[160,566,273],{"class":166},[160,568,276],{"class":177},[160,570,571],{"class":162,"line":279},[160,572,247],{"class":177},[160,574,575],{"class":162,"line":284},[160,576,287],{"class":177},[39,578,579,580,582,583,585,586,588],{},"This code is also not ",[85,581,105],{"href":104}," . A ",[85,584,293],{"href":92}," exists because ",[43,587,78],{}," is a non-atomic compound operation.",[124,590,592],{"id":591},"noncompliant-code-example-volatile","Noncompliant Code Example (Volatile)",[39,594,595,596,598],{},"Declaring ",[43,597,137],{}," volatile also fails to solve the problem:",[147,600,601],{"quality":149},[151,602,604],{"className":153,"code":603,"language":155,"meta":156,"style":156},"final class Flag {\n  private volatile boolean flag = true;\n\n  public void toggle() {  \u002F\u002F Unsafe\n    flag ^= true;\n  }\n\n  public boolean getFlag() { \u002F\u002F Safe\n    return flag;\n  }\n}\n",[43,605,606,616,633,637,649,659,663,667,680,686,690],{"__ignoreMap":156},[160,607,608,610,612,614],{"class":162,"line":163},[160,609,167],{"class":166},[160,611,170],{"class":166},[160,613,174],{"class":173},[160,615,178],{"class":177},[160,617,618,620,623,625,627,629,631],{"class":162,"line":181},[160,619,184],{"class":166},[160,621,622],{"class":166}," volatile",[160,624,188],{"class":187},[160,626,191],{"class":177},[160,628,194],{"class":166},[160,630,198],{"class":197},[160,632,201],{"class":177},[160,634,635],{"class":162,"line":204},[160,636,207],{"emptyLinePlaceholder":7},[160,638,639,641,643,645,647],{"class":162,"line":210},[160,640,213],{"class":166},[160,642,216],{"class":187},[160,644,220],{"class":219},[160,646,223],{"class":177},[160,648,227],{"class":226},[160,650,651,653,655,657],{"class":162,"line":230},[160,652,233],{"class":177},[160,654,78],{"class":166},[160,656,198],{"class":197},[160,658,201],{"class":177},[160,660,661],{"class":162,"line":244},[160,662,247],{"class":177},[160,664,665],{"class":162,"line":250},[160,666,207],{"emptyLinePlaceholder":7},[160,668,669,671,673,675,677],{"class":162,"line":255},[160,670,213],{"class":166},[160,672,188],{"class":187},[160,674,262],{"class":219},[160,676,265],{"class":177},[160,678,679],{"class":226},"\u002F\u002F Safe\n",[160,681,682,684],{"class":162,"line":270},[160,683,273],{"class":166},[160,685,276],{"class":177},[160,687,688],{"class":162,"line":279},[160,689,247],{"class":177},[160,691,692],{"class":162,"line":284},[160,693,287],{"class":177},[39,695,696],{},"This code remains unsuitable for multithreaded use because declaring a variable volatile fails to guarantee the atomicity of compound operations on the variable.",[124,698,700],{"id":699},"compliant-solution-synchronization","Compliant Solution (Synchronization)",[39,702,703,704,79,706,709],{},"This compliant solution declares both the ",[43,705,141],{},[43,707,708],{},"getFlag()"," methods as synchronized:",[147,711,713],{"quality":712},"good",[151,714,716],{"className":153,"code":715,"language":155,"meta":156,"style":156},"final class Flag {\n  private boolean flag = true;\n\n  public synchronized void toggle() {\n    flag ^= true; \u002F\u002F Same as flag = !flag;\n  }\n\n  public synchronized boolean getFlag() {\n    return flag;\n  }\n}\n",[43,717,718,728,742,746,760,773,777,781,793,799,803],{"__ignoreMap":156},[160,719,720,722,724,726],{"class":162,"line":163},[160,721,167],{"class":166},[160,723,170],{"class":166},[160,725,174],{"class":173},[160,727,178],{"class":177},[160,729,730,732,734,736,738,740],{"class":162,"line":181},[160,731,184],{"class":166},[160,733,188],{"class":187},[160,735,191],{"class":177},[160,737,194],{"class":166},[160,739,198],{"class":197},[160,741,201],{"class":177},[160,743,744],{"class":162,"line":204},[160,745,207],{"emptyLinePlaceholder":7},[160,747,748,750,753,755,757],{"class":162,"line":210},[160,749,213],{"class":166},[160,751,752],{"class":166}," synchronized",[160,754,216],{"class":187},[160,756,220],{"class":219},[160,758,759],{"class":177},"() {\n",[160,761,762,764,766,768,771],{"class":162,"line":230},[160,763,233],{"class":177},[160,765,78],{"class":166},[160,767,198],{"class":197},[160,769,770],{"class":177},"; ",[160,772,542],{"class":226},[160,774,775],{"class":162,"line":244},[160,776,247],{"class":177},[160,778,779],{"class":162,"line":250},[160,780,207],{"emptyLinePlaceholder":7},[160,782,783,785,787,789,791],{"class":162,"line":255},[160,784,213],{"class":166},[160,786,752],{"class":166},[160,788,188],{"class":187},[160,790,262],{"class":219},[160,792,759],{"class":177},[160,794,795,797],{"class":162,"line":270},[160,796,273],{"class":166},[160,798,276],{"class":177},[160,800,801],{"class":162,"line":279},[160,802,247],{"class":177},[160,804,805],{"class":162,"line":284},[160,806,287],{"class":177},[39,808,809,810,812,813,816],{},"This solution guards reads and writes to the ",[43,811,137],{}," field with a lock on the instance, that is, ",[43,814,815],{},"this"," . Furthermore, synchronization ensures that changes are visible to all threads. Now, only two execution orders are possible, one of which is shown in the following scenario:",[311,818,819,831],{},[314,820,821],{},[317,822,823,825,827,829],{},[320,824],{},[320,826],{},[320,828],{},[320,830],{},[329,832,833,843,859,873,889,906,921],{},[317,834,835,837,839,841],{},[334,836,336],{},[334,838,339],{},[334,840,342],{},[334,842,345],{},[317,844,845,847,849,855],{},[334,846,350],{},[334,848,353],{},[334,850,851,134,853],{},[114,852,358],{},[360,854,350],{},[334,856,364,857,367],{},[43,858,137],{},[317,860,861,863,865,871],{},[334,862,372],{},[334,864,353],{},[334,866,867,134,869],{},[114,868,358],{},[360,870,350],{},[334,872,401],{},[317,874,875,877,879,885],{},[334,876,390],{},[334,878,424],{},[334,880,881,134,883],{},[114,882,358],{},[360,884,350],{},[334,886,433,887],{},[43,888,137],{},[317,890,891,893,895,901],{},[334,892,406],{},[334,894,424],{},[334,896,897,134,899],{},[114,898,358],{},[360,900,372],{},[334,902,364,903,905],{},[43,904,137],{}," , false, into a temporary variable",[317,907,908,910,912,918],{},[334,909,421],{},[334,911,424],{},[334,913,914,134,916],{},[114,915,358],{},[360,917,372],{},[334,919,920],{},"Toggles the temporary variable to true",[317,922,923,925,927,933],{},[334,924,440],{},[334,926,353],{},[334,928,929,134,931],{},[114,930,358],{},[360,932,372],{},[334,934,433,935],{},[43,936,137],{},[39,938,939,940,134,942,944,945,134,947,98,949,952,953,957],{},"The second execution order involves the same operations, but ",[114,941,358],{},[360,943,372],{}," starts and finishes before ",[114,946,358],{},[360,948,350],{},[950,951],"br",{},"\nCompliance with ",[85,954,956],{"href":955},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Flocking-lck\u002Flck00-j","LCK00-J. Use private final lock objects to synchronize classes that may interact with untrusted code"," can reduce the likelihood of misuse by ensuring that untrusted callers cannot access the lock object.",[124,959,961],{"id":960},"compliant-solution-volatile-read-synchronized-write","Compliant Solution (Volatile-Read, Synchronized-Write)",[39,963,964,965,967,968,970,971,973,974,976,977,979],{},"In this compliant solution, the ",[43,966,708],{}," method is not synchronized, and ",[43,969,137],{}," is declared as volatile. This solution is compliant because the read of ",[43,972,137],{}," in the ",[43,975,708],{}," method is an atomic operation and the volatile qualification assures visibility. The ",[43,978,141],{}," method still requires synchronization because it performs a non-atomic operation.",[147,981,982],{"quality":712},[151,983,985],{"className":153,"code":984,"language":155,"meta":156,"style":156},"final class Flag {\n  private volatile boolean flag = true;\n\n  public synchronized void toggle() {\n    flag ^= true; \u002F\u002F Same as flag = !flag;\n  }\n\n  public boolean getFlag() {\n    return flag;\n  }\n}\n",[43,986,987,997,1013,1017,1029,1041,1045,1049,1059,1065,1069],{"__ignoreMap":156},[160,988,989,991,993,995],{"class":162,"line":163},[160,990,167],{"class":166},[160,992,170],{"class":166},[160,994,174],{"class":173},[160,996,178],{"class":177},[160,998,999,1001,1003,1005,1007,1009,1011],{"class":162,"line":181},[160,1000,184],{"class":166},[160,1002,622],{"class":166},[160,1004,188],{"class":187},[160,1006,191],{"class":177},[160,1008,194],{"class":166},[160,1010,198],{"class":197},[160,1012,201],{"class":177},[160,1014,1015],{"class":162,"line":204},[160,1016,207],{"emptyLinePlaceholder":7},[160,1018,1019,1021,1023,1025,1027],{"class":162,"line":210},[160,1020,213],{"class":166},[160,1022,752],{"class":166},[160,1024,216],{"class":187},[160,1026,220],{"class":219},[160,1028,759],{"class":177},[160,1030,1031,1033,1035,1037,1039],{"class":162,"line":230},[160,1032,233],{"class":177},[160,1034,78],{"class":166},[160,1036,198],{"class":197},[160,1038,770],{"class":177},[160,1040,542],{"class":226},[160,1042,1043],{"class":162,"line":244},[160,1044,247],{"class":177},[160,1046,1047],{"class":162,"line":250},[160,1048,207],{"emptyLinePlaceholder":7},[160,1050,1051,1053,1055,1057],{"class":162,"line":255},[160,1052,213],{"class":166},[160,1054,188],{"class":187},[160,1056,262],{"class":219},[160,1058,759],{"class":177},[160,1060,1061,1063],{"class":162,"line":270},[160,1062,273],{"class":166},[160,1064,276],{"class":177},[160,1066,1067],{"class":162,"line":279},[160,1068,247],{"class":177},[160,1070,1071],{"class":162,"line":284},[160,1072,287],{"class":177},[39,1074,1075,1076,1080],{},"This approach must not be used for getter methods that perform any additional operations other than returning the value of a volatile field without use of synchronization. Unless read performance is critical, this technique may lack significant advantages over synchronization [ ",[85,1077,1079],{"href":1078},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Goetz06","Goetz 2006"," ].",[124,1082,1084],{"id":1083},"compliant-solution-read-write-lock","Compliant Solution (Read-Write Lock)",[39,1086,1087],{},"This compliant solution uses a read-write lock to ensure atomicity and visibility:",[147,1089,1090],{"quality":712},[151,1091,1093],{"className":153,"code":1092,"language":155,"meta":156,"style":156},"final class Flag {\n  private boolean flag = true;\n  private final ReadWriteLock lock = new ReentrantReadWriteLock();\n  private final Lock readLock = lock.readLock();\n  private final Lock writeLock = lock.writeLock();\n\n  public void toggle() {\n    writeLock.lock();\n    try {\n      flag ^= true; \u002F\u002F Same as flag = !flag;\n    } finally {\n      writeLock.unlock();\n    }\n  }\n\n  public boolean getFlag() {\n    readLock.lock();\n    try {\n      return flag;\n    } finally {\n      readLock.unlock();\n    }\n  }\n}\n",[43,1094,1095,1105,1119,1144,1166,1186,1190,1200,1210,1217,1230,1240,1251,1257,1262,1267,1278,1288,1295,1303,1312,1322,1327,1332],{"__ignoreMap":156},[160,1096,1097,1099,1101,1103],{"class":162,"line":163},[160,1098,167],{"class":166},[160,1100,170],{"class":166},[160,1102,174],{"class":173},[160,1104,178],{"class":177},[160,1106,1107,1109,1111,1113,1115,1117],{"class":162,"line":181},[160,1108,184],{"class":166},[160,1110,188],{"class":187},[160,1112,191],{"class":177},[160,1114,194],{"class":166},[160,1116,198],{"class":197},[160,1118,201],{"class":177},[160,1120,1121,1123,1126,1130,1133,1135,1138,1141],{"class":162,"line":204},[160,1122,184],{"class":166},[160,1124,1125],{"class":166}," final",[160,1127,1129],{"class":1128},"sk8M1"," ReadWriteLock",[160,1131,1132],{"class":177}," lock ",[160,1134,194],{"class":166},[160,1136,1137],{"class":166}," new",[160,1139,1140],{"class":219}," ReentrantReadWriteLock",[160,1142,1143],{"class":177},"();\n",[160,1145,1146,1148,1150,1153,1156,1158,1161,1164],{"class":162,"line":210},[160,1147,184],{"class":166},[160,1149,1125],{"class":166},[160,1151,1152],{"class":1128}," Lock",[160,1154,1155],{"class":177}," readLock ",[160,1157,194],{"class":166},[160,1159,1160],{"class":177}," lock.",[160,1162,1163],{"class":219},"readLock",[160,1165,1143],{"class":177},[160,1167,1168,1170,1172,1174,1177,1179,1181,1184],{"class":162,"line":230},[160,1169,184],{"class":166},[160,1171,1125],{"class":166},[160,1173,1152],{"class":1128},[160,1175,1176],{"class":177}," writeLock ",[160,1178,194],{"class":166},[160,1180,1160],{"class":177},[160,1182,1183],{"class":219},"writeLock",[160,1185,1143],{"class":177},[160,1187,1188],{"class":162,"line":244},[160,1189,207],{"emptyLinePlaceholder":7},[160,1191,1192,1194,1196,1198],{"class":162,"line":250},[160,1193,213],{"class":166},[160,1195,216],{"class":187},[160,1197,220],{"class":219},[160,1199,759],{"class":177},[160,1201,1202,1205,1208],{"class":162,"line":255},[160,1203,1204],{"class":177},"    writeLock.",[160,1206,1207],{"class":219},"lock",[160,1209,1143],{"class":177},[160,1211,1212,1215],{"class":162,"line":270},[160,1213,1214],{"class":166},"    try",[160,1216,178],{"class":177},[160,1218,1219,1222,1224,1226,1228],{"class":162,"line":279},[160,1220,1221],{"class":177},"      flag ",[160,1223,78],{"class":166},[160,1225,198],{"class":197},[160,1227,770],{"class":177},[160,1229,542],{"class":226},[160,1231,1232,1235,1238],{"class":162,"line":284},[160,1233,1234],{"class":177},"    } ",[160,1236,1237],{"class":166},"finally",[160,1239,178],{"class":177},[160,1241,1243,1246,1249],{"class":162,"line":1242},12,[160,1244,1245],{"class":177},"      writeLock.",[160,1247,1248],{"class":219},"unlock",[160,1250,1143],{"class":177},[160,1252,1254],{"class":162,"line":1253},13,[160,1255,1256],{"class":177},"    }\n",[160,1258,1260],{"class":162,"line":1259},14,[160,1261,247],{"class":177},[160,1263,1265],{"class":162,"line":1264},15,[160,1266,207],{"emptyLinePlaceholder":7},[160,1268,1270,1272,1274,1276],{"class":162,"line":1269},16,[160,1271,213],{"class":166},[160,1273,188],{"class":187},[160,1275,262],{"class":219},[160,1277,759],{"class":177},[160,1279,1281,1284,1286],{"class":162,"line":1280},17,[160,1282,1283],{"class":177},"    readLock.",[160,1285,1207],{"class":219},[160,1287,1143],{"class":177},[160,1289,1291,1293],{"class":162,"line":1290},18,[160,1292,1214],{"class":166},[160,1294,178],{"class":177},[160,1296,1298,1301],{"class":162,"line":1297},19,[160,1299,1300],{"class":166},"      return",[160,1302,276],{"class":177},[160,1304,1306,1308,1310],{"class":162,"line":1305},20,[160,1307,1234],{"class":177},[160,1309,1237],{"class":166},[160,1311,178],{"class":177},[160,1313,1315,1318,1320],{"class":162,"line":1314},21,[160,1316,1317],{"class":177},"      readLock.",[160,1319,1248],{"class":219},[160,1321,1143],{"class":177},[160,1323,1325],{"class":162,"line":1324},22,[160,1326,1256],{"class":177},[160,1328,1330],{"class":162,"line":1329},23,[160,1331,247],{"class":177},[160,1333,1335],{"class":162,"line":1334},24,[160,1336,287],{"class":177},[39,1338,1339,1340,1342],{},"Read-write locks allow shared state to be accessed by multiple readers or a single writer but never both. According to Goetz [ ",[85,1341,1079],{"href":1078}," ]:",[1344,1345,1346],"blockquote",{},[39,1347,1348],{},"In practice, read-write locks can improve performance for frequently accessed read-mostly data structures on multiprocessor systems; under other conditions they perform slightly worse than exclusive locks due to their greater complexity.",[39,1350,1351],{},"Profiling the application can determine the suitability of read-write locks.",[124,1353,1355,1356,1359],{"id":1354},"compliant-solution-atomicboolean","Compliant Solution ( ",[43,1357,1358],{},"AtomicBoolean"," )",[39,1361,1362,1363,1365,1366,145],{},"This compliant solution declares ",[43,1364,137],{}," to be of type ",[43,1367,1358],{},[147,1369,1370],{"quality":712},[151,1371,1373],{"className":153,"code":1372,"language":155,"meta":156,"style":156},"import java.util.concurrent.atomic.AtomicBoolean;\n\nfinal class Flag {\n  private AtomicBoolean flag = new AtomicBoolean(true);\n\n  public void toggle() {\n    boolean temp;\n    do {\n      temp = flag.get();\n    } while (!flag.compareAndSet(temp, !temp));\n  }\n\n  public AtomicBoolean getFlag() {\n    return flag;\n  }\n}\n",[43,1374,1375,1386,1390,1400,1423,1427,1437,1445,1452,1467,1494,1498,1502,1512,1518,1522],{"__ignoreMap":156},[160,1376,1377,1380,1384],{"class":162,"line":163},[160,1378,1379],{"class":166},"import",[160,1381,1383],{"class":1382},"s-ngx"," java.util.concurrent.atomic.AtomicBoolean",[160,1385,201],{"class":177},[160,1387,1388],{"class":162,"line":181},[160,1389,207],{"emptyLinePlaceholder":7},[160,1391,1392,1394,1396,1398],{"class":162,"line":204},[160,1393,167],{"class":166},[160,1395,170],{"class":166},[160,1397,174],{"class":173},[160,1399,178],{"class":177},[160,1401,1402,1404,1407,1409,1411,1413,1415,1418,1420],{"class":162,"line":210},[160,1403,184],{"class":166},[160,1405,1406],{"class":1128}," AtomicBoolean",[160,1408,191],{"class":177},[160,1410,194],{"class":166},[160,1412,1137],{"class":166},[160,1414,1406],{"class":219},[160,1416,1417],{"class":177},"(",[160,1419,353],{"class":197},[160,1421,1422],{"class":177},");\n",[160,1424,1425],{"class":162,"line":230},[160,1426,207],{"emptyLinePlaceholder":7},[160,1428,1429,1431,1433,1435],{"class":162,"line":244},[160,1430,213],{"class":166},[160,1432,216],{"class":187},[160,1434,220],{"class":219},[160,1436,759],{"class":177},[160,1438,1439,1442],{"class":162,"line":250},[160,1440,1441],{"class":187},"    boolean",[160,1443,1444],{"class":177}," temp;\n",[160,1446,1447,1450],{"class":162,"line":255},[160,1448,1449],{"class":166},"    do",[160,1451,178],{"class":177},[160,1453,1454,1457,1459,1462,1465],{"class":162,"line":270},[160,1455,1456],{"class":177},"      temp ",[160,1458,194],{"class":166},[160,1460,1461],{"class":177}," flag.",[160,1463,1464],{"class":219},"get",[160,1466,1143],{"class":177},[160,1468,1469,1471,1474,1477,1480,1483,1486,1489,1491],{"class":162,"line":279},[160,1470,1234],{"class":177},[160,1472,1473],{"class":166},"while",[160,1475,1476],{"class":177}," (",[160,1478,1479],{"class":166},"!",[160,1481,1482],{"class":177},"flag.",[160,1484,1485],{"class":219},"compareAndSet",[160,1487,1488],{"class":177},"(temp, ",[160,1490,1479],{"class":166},[160,1492,1493],{"class":177},"temp));\n",[160,1495,1496],{"class":162,"line":284},[160,1497,247],{"class":177},[160,1499,1500],{"class":162,"line":1242},[160,1501,207],{"emptyLinePlaceholder":7},[160,1503,1504,1506,1508,1510],{"class":162,"line":1253},[160,1505,213],{"class":166},[160,1507,1406],{"class":1128},[160,1509,262],{"class":219},[160,1511,759],{"class":177},[160,1513,1514,1516],{"class":162,"line":1259},[160,1515,273],{"class":166},[160,1517,276],{"class":177},[160,1519,1520],{"class":162,"line":1264},[160,1521,247],{"class":177},[160,1523,1524],{"class":162,"line":1269},[160,1525,287],{"class":177},[39,1527,473,1528,1530,1531,1534,1535,1537],{},[43,1529,137],{}," variable is updated using the ",[43,1532,1533],{},"compareAndSet()"," method of the ",[43,1536,1358],{}," class. All updates are visible to other threads.",[124,1539,1541],{"id":1540},"noncompliant-code-example-addition-of-primitives","Noncompliant Code Example (Addition of Primitives)",[39,1543,1544,1545,1548,1549,79,1551,1554,1555,1558,1559,1561,1562,1566],{},"In this noncompliant code example, multiple threads can invoke the ",[43,1546,1547],{},"setValues()"," method to set the ",[43,1550,85],{},[43,1552,1553],{},"b"," fields. Because this class fails to test for integer overflow, users of the ",[43,1556,1557],{},"Adder"," class must ensure that the arguments to the ",[43,1560,1547],{}," method can be added without overflow (see ",[85,1563,1565],{"href":1564},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fnumeric-types-and-operations-num\u002Fnum00-j","NUM00-J. Detect or prevent integer overflow"," for more information).",[147,1568,1569],{"quality":149},[151,1570,1572],{"className":153,"code":1571,"language":155,"meta":156,"style":156},"final class Adder {\n  private int a;\n  private int b;\n\n  public int getSum() {\n    return a + b;\n  }\n\n  public void setValues(int a, int b) {\n    this.a = a;\n    this.b = b;\n  }\n}\n",[43,1573,1574,1585,1595,1604,1608,1619,1631,1635,1639,1668,1681,1692,1696],{"__ignoreMap":156},[160,1575,1576,1578,1580,1583],{"class":162,"line":163},[160,1577,167],{"class":166},[160,1579,170],{"class":166},[160,1581,1582],{"class":173}," Adder",[160,1584,178],{"class":177},[160,1586,1587,1589,1592],{"class":162,"line":181},[160,1588,184],{"class":166},[160,1590,1591],{"class":187}," int",[160,1593,1594],{"class":177}," a;\n",[160,1596,1597,1599,1601],{"class":162,"line":204},[160,1598,184],{"class":166},[160,1600,1591],{"class":187},[160,1602,1603],{"class":177}," b;\n",[160,1605,1606],{"class":162,"line":210},[160,1607,207],{"emptyLinePlaceholder":7},[160,1609,1610,1612,1614,1617],{"class":162,"line":230},[160,1611,213],{"class":166},[160,1613,1591],{"class":187},[160,1615,1616],{"class":219}," getSum",[160,1618,759],{"class":177},[160,1620,1621,1623,1626,1629],{"class":162,"line":244},[160,1622,273],{"class":166},[160,1624,1625],{"class":177}," a ",[160,1627,1628],{"class":166},"+",[160,1630,1603],{"class":177},[160,1632,1633],{"class":162,"line":250},[160,1634,247],{"class":177},[160,1636,1637],{"class":162,"line":255},[160,1638,207],{"emptyLinePlaceholder":7},[160,1640,1641,1643,1645,1648,1650,1653,1657,1660,1662,1665],{"class":162,"line":270},[160,1642,213],{"class":166},[160,1644,216],{"class":187},[160,1646,1647],{"class":219}," setValues",[160,1649,1417],{"class":177},[160,1651,1652],{"class":187},"int",[160,1654,1656],{"class":1655},"sTHNf"," a",[160,1658,1659],{"class":177},", ",[160,1661,1652],{"class":187},[160,1663,1664],{"class":1655}," b",[160,1666,1667],{"class":177},") {\n",[160,1669,1670,1674,1677,1679],{"class":162,"line":279},[160,1671,1673],{"class":1672},"sP7S_","    this",[160,1675,1676],{"class":177},".a ",[160,1678,194],{"class":166},[160,1680,1594],{"class":177},[160,1682,1683,1685,1688,1690],{"class":162,"line":284},[160,1684,1673],{"class":1672},[160,1686,1687],{"class":177},".b ",[160,1689,194],{"class":166},[160,1691,1603],{"class":177},[160,1693,1694],{"class":162,"line":1242},[160,1695,247],{"class":177},[160,1697,1698],{"class":162,"line":1253},[160,1699,287],{"class":177},[39,1701,473,1702,1705,1706,1709,1710,79,1712,1714,1715,79,1718,1721,1722,1724,1725,1728,1729,1731,1732,1734,1735,1737,1738,79,1740,1742,1743,1745,1746,1748,1749,1745,1751,98],{},[43,1703,1704],{},"getSum()"," method contains a ",[85,1707,1708],{"href":96},"race condition"," . For example, when ",[43,1711,85],{},[43,1713,1553],{}," currently have the values ",[43,1716,1717],{},"0",[43,1719,1720],{},"Integer.MAX_VALUE"," , respectively, and one thread calls ",[43,1723,1704],{}," while another calls ",[43,1726,1727],{},"  setValues(Integer.MAX_VALUE, 0) "," , the ",[43,1730,1704],{}," method might return either ",[43,1733,1717],{}," or ",[43,1736,1720],{}," , or it might overflow. Overflow will occur when the first thread reads ",[43,1739,85],{},[43,1741,1553],{}," after the second thread has set the value of ",[43,1744,85],{}," to ",[43,1747,1720],{}," but before it has set the value of ",[43,1750,1553],{},[43,1752,1717],{},[39,1754,1755],{},"Note that declaring the variables as volatile fails to resolve the issue because these compound operations involve reads and writes of multiple variables.",[124,1757,1759],{"id":1758},"noncompliant-code-example-addition-of-atomic-integers","Noncompliant Code Example (Addition of Atomic Integers)",[39,1761,1762,1763,79,1765,1767],{},"In this noncompliant code example, ",[43,1764,85],{},[43,1766,1553],{}," are replaced with atomic integers:",[147,1769,1770],{"quality":149},[151,1771,1773],{"className":153,"code":1772,"language":155,"meta":156,"style":156},"final class Adder {\n  private final AtomicInteger a = new AtomicInteger();\n  private final AtomicInteger b = new AtomicInteger();\n\n  public int getSum() {\n    return a.get() + b.get();\n  }\n\n  public void setValues(int a, int b) {\n    this.a.set(a);\n    this.b.set(b);\n  }\n}\n",[43,1774,1775,1785,1804,1823,1827,1837,1858,1862,1866,1888,1901,1913,1917],{"__ignoreMap":156},[160,1776,1777,1779,1781,1783],{"class":162,"line":163},[160,1778,167],{"class":166},[160,1780,170],{"class":166},[160,1782,1582],{"class":173},[160,1784,178],{"class":177},[160,1786,1787,1789,1791,1794,1796,1798,1800,1802],{"class":162,"line":181},[160,1788,184],{"class":166},[160,1790,1125],{"class":166},[160,1792,1793],{"class":1128}," AtomicInteger",[160,1795,1625],{"class":177},[160,1797,194],{"class":166},[160,1799,1137],{"class":166},[160,1801,1793],{"class":219},[160,1803,1143],{"class":177},[160,1805,1806,1808,1810,1812,1815,1817,1819,1821],{"class":162,"line":204},[160,1807,184],{"class":166},[160,1809,1125],{"class":166},[160,1811,1793],{"class":1128},[160,1813,1814],{"class":177}," b ",[160,1816,194],{"class":166},[160,1818,1137],{"class":166},[160,1820,1793],{"class":219},[160,1822,1143],{"class":177},[160,1824,1825],{"class":162,"line":210},[160,1826,207],{"emptyLinePlaceholder":7},[160,1828,1829,1831,1833,1835],{"class":162,"line":230},[160,1830,213],{"class":166},[160,1832,1591],{"class":187},[160,1834,1616],{"class":219},[160,1836,759],{"class":177},[160,1838,1839,1841,1844,1846,1849,1851,1854,1856],{"class":162,"line":244},[160,1840,273],{"class":166},[160,1842,1843],{"class":177}," a.",[160,1845,1464],{"class":219},[160,1847,1848],{"class":177},"() ",[160,1850,1628],{"class":166},[160,1852,1853],{"class":177}," b.",[160,1855,1464],{"class":219},[160,1857,1143],{"class":177},[160,1859,1860],{"class":162,"line":250},[160,1861,247],{"class":177},[160,1863,1864],{"class":162,"line":255},[160,1865,207],{"emptyLinePlaceholder":7},[160,1867,1868,1870,1872,1874,1876,1878,1880,1882,1884,1886],{"class":162,"line":270},[160,1869,213],{"class":166},[160,1871,216],{"class":187},[160,1873,1647],{"class":219},[160,1875,1417],{"class":177},[160,1877,1652],{"class":187},[160,1879,1656],{"class":1655},[160,1881,1659],{"class":177},[160,1883,1652],{"class":187},[160,1885,1664],{"class":1655},[160,1887,1667],{"class":177},[160,1889,1890,1892,1895,1898],{"class":162,"line":279},[160,1891,1673],{"class":1672},[160,1893,1894],{"class":177},".a.",[160,1896,1897],{"class":219},"set",[160,1899,1900],{"class":177},"(a);\n",[160,1902,1903,1905,1908,1910],{"class":162,"line":284},[160,1904,1673],{"class":1672},[160,1906,1907],{"class":177},".b.",[160,1909,1897],{"class":219},[160,1911,1912],{"class":177},"(b);\n",[160,1914,1915],{"class":162,"line":1242},[160,1916,247],{"class":177},[160,1918,1919],{"class":162,"line":1253},[160,1920,287],{"class":177},[39,1922,1923,1924,1926,1927,1929,1930,1933],{},"The simple replacement of the two ",[43,1925,1652],{}," fields with atomic integers fails to eliminate the ",[85,1928,1708],{"href":96}," because the compound operation ",[43,1931,1932],{},"  a.get() + b.get() "," is still non-atomic.",[124,1935,1937],{"id":1936},"compliant-solution-addition","Compliant Solution (Addition)",[39,1939,1940,1941,79,1943,1945],{},"This compliant solution synchronizes the ",[43,1942,1547],{},[43,1944,1704],{}," methods to ensure atomicity:",[147,1947,1948],{"quality":712},[151,1949,1951],{"className":153,"code":1950,"language":155,"meta":156,"style":156},"final class Adder {\n  private int a;\n  private int b;\n\n  public synchronized int getSum() {\n    \u002F\u002F Check for overflow \n    return a + b;\n  }\n\n  public synchronized void setValues(int a, int b) {\n    this.a = a;\n    this.b = b;\n  }\n}\n",[43,1952,1953,1963,1971,1979,1983,1995,2000,2010,2014,2018,2042,2052,2062,2066],{"__ignoreMap":156},[160,1954,1955,1957,1959,1961],{"class":162,"line":163},[160,1956,167],{"class":166},[160,1958,170],{"class":166},[160,1960,1582],{"class":173},[160,1962,178],{"class":177},[160,1964,1965,1967,1969],{"class":162,"line":181},[160,1966,184],{"class":166},[160,1968,1591],{"class":187},[160,1970,1594],{"class":177},[160,1972,1973,1975,1977],{"class":162,"line":204},[160,1974,184],{"class":166},[160,1976,1591],{"class":187},[160,1978,1603],{"class":177},[160,1980,1981],{"class":162,"line":210},[160,1982,207],{"emptyLinePlaceholder":7},[160,1984,1985,1987,1989,1991,1993],{"class":162,"line":230},[160,1986,213],{"class":166},[160,1988,752],{"class":166},[160,1990,1591],{"class":187},[160,1992,1616],{"class":219},[160,1994,759],{"class":177},[160,1996,1997],{"class":162,"line":244},[160,1998,1999],{"class":226},"    \u002F\u002F Check for overflow \n",[160,2001,2002,2004,2006,2008],{"class":162,"line":250},[160,2003,273],{"class":166},[160,2005,1625],{"class":177},[160,2007,1628],{"class":166},[160,2009,1603],{"class":177},[160,2011,2012],{"class":162,"line":255},[160,2013,247],{"class":177},[160,2015,2016],{"class":162,"line":270},[160,2017,207],{"emptyLinePlaceholder":7},[160,2019,2020,2022,2024,2026,2028,2030,2032,2034,2036,2038,2040],{"class":162,"line":279},[160,2021,213],{"class":166},[160,2023,752],{"class":166},[160,2025,216],{"class":187},[160,2027,1647],{"class":219},[160,2029,1417],{"class":177},[160,2031,1652],{"class":187},[160,2033,1656],{"class":1655},[160,2035,1659],{"class":177},[160,2037,1652],{"class":187},[160,2039,1664],{"class":1655},[160,2041,1667],{"class":177},[160,2043,2044,2046,2048,2050],{"class":162,"line":284},[160,2045,1673],{"class":1672},[160,2047,1676],{"class":177},[160,2049,194],{"class":166},[160,2051,1594],{"class":177},[160,2053,2054,2056,2058,2060],{"class":162,"line":1242},[160,2055,1673],{"class":1672},[160,2057,1687],{"class":177},[160,2059,194],{"class":166},[160,2061,1603],{"class":177},[160,2063,2064],{"class":162,"line":1253},[160,2065,247],{"class":177},[160,2067,2068],{"class":162,"line":1259},[160,2069,287],{"class":177},[39,2071,2072,2073,2076,2077,2079,2080,98],{},"The operations within the synchronized methods are now atomic with respect to other synchronized methods that lock on that object's ",[114,2074,2075],{},"monitor"," (that is, its intrinsic lock). It is now possible, for example, to add overflow checking to the synchronized ",[43,2078,1704],{}," method without introducing the possibility of a ",[85,2081,1708],{"href":96},[124,2083,2085],{"id":2084},"risk-assessment","Risk Assessment",[39,2087,2088],{},"When operations on shared variables are not atomic, unexpected results can be produced. For example, information can be disclosed inadvertently because one user can receive information about other users.",[311,2090,2091,2092,2091,2119],{},"\n  ",[314,2093,2094,2095,2091],{},"\n    ",[317,2096,2097,2098,2097,2101,2097,2104,2097,2107,2097,2110,2097,2113,2097,2116,2094],{},"\n      ",[320,2099,2100],{},"Rule",[320,2102,2103],{},"Severity",[320,2105,2106],{},"Likelihood",[320,2108,2109],{},"Detectable",[320,2111,2112],{},"Repairable",[320,2114,2115],{},"Priority",[320,2117,2118],{},"Level",[329,2120,2094,2121,2091],{},[317,2122,2097,2123,2097,2126,2097,2129,2097,2132,2097,2135,2097,2138,2097,2144,2094],{},[334,2124,2125],{},"VNA02-J",[334,2127,2128],{},"Medium",[334,2130,2131],{},"Probable",[334,2133,2134],{},"Yes",[334,2136,2137],{},"No",[334,2139,2141],{"style":2140},"color: #f1c40f;",[1553,2142,2143],{},"P8",[334,2145,2146],{"style":2140},[1553,2147,2148],{},"L2",[124,2150,2152],{"id":2151},"automated-detection","Automated Detection",[39,2154,2155,2156,98],{},"Some available static analysis tools can detect the instances of non-atomic update of a concurrently shared value. The result of the update is determined by the interleaving of thread execution. These tools can detect the instances where thread-shared data is accessed without holding an appropriate lock, possibly causing a ",[85,2157,1708],{"href":96},[311,2159,2162],{"className":2160},[2161],"wrapped",[329,2163,2164,2180,2258,2287,2315,2344],{},[317,2165,2168,2171,2174,2177],{"className":2166},[2167],"header",[320,2169,2170],{},"Tool",[320,2172,2173],{},"Version",[320,2175,2176],{},"Checker",[320,2178,2179],{},"Description",[317,2181,2184,2190,2193,2255],{"className":2182},[2183],"odd",[334,2185,2186],{},[85,2187,2189],{"href":2188},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcoverity","Coverity",[334,2191,2192],{},"7.5",[334,2194,2195],{},[39,2196,2197,2201,2203,2206,2208,2211,2213,2215,2217,2220,2222,2225,2227,2230,2232,2235,2237,2240,2242,2245,2247,2250,2252],{},[2198,2199,2200],"strong",{},"GUARDED_BY_VIOLATION",[950,2202],{},[2198,2204,2205],{},"INDIRECT_GUARDED_BY_VIOLATION",[950,2207],{},[2198,2209,2210],{},"NON_STATIC_GUARDING_STATIC",[950,2212],{},[2198,2214,2210],{},[950,2216],{},[2198,2218,2219],{},"SERVLET_ATOMICITY",[950,2221],{},[2198,2223,2224],{},"FB.IS2_INCONSISTENT_SYNC",[950,2226],{},[2198,2228,2229],{},"FB.IS_FIELD_NOT_GUARDED",[950,2231],{},[2198,2233,2234],{},"FB.IS_INCONSISTENT_SYNC",[950,2236],{},[2198,2238,2239],{},"FB.STCAL_INVOKE_ON_STATIC_ CALENDAR_INSTANCE",[950,2241],{},[2198,2243,2244],{},"FB.STCAL_INVOKE_ON_STATIC_ DATE_FORMAT_INSTANCE",[950,2246],{},[2198,2248,2249],{},"FB.STCAL_STATIC_CALENDAR_ INSTANCE",[950,2251],{},[2198,2253,2254],{},"FB.STCAL_STATIC_SIMPLE_DATE_ FORMAT_INSTANCE",[334,2256,2257],{},"Implemented",[317,2259,2262,2268,2278,2283],{"className":2260},[2261],"even",[334,2263,2264],{},[85,2265,2267],{"href":2266},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fklocwork","Klocwork",[334,2269,2270],{},[2271,2272,2275],"div",{"className":2273},[2274],"content-wrapper",[39,2276,2277],{},"2025.2",[334,2279,2280],{},[2198,2281,2282],{},"SV.SHARED.VAR",[334,2284,2285],{},[950,2286],{},[317,2288,2290,2296,2301,2309],{"className":2289},[2183],[334,2291,2292],{},[85,2293,2295],{"href":2294},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fparasoft","Parasoft Jtest",[334,2297,2298],{},[2271,2299,2277],{"className":2300},[2274],[334,2302,2303],{},[2198,2304,2305,2306,2308],{},"CERT.VNA02.SSUG",[950,2307],{},"\nCERT.VNA02.MRAV",[334,2310,2311,2312,2314],{},"Make the get method for a field synchronized if the set method is synchronized",[950,2313],{},"\nAccess related Atomic variables in a synchronized block",[317,2316,2318,2324,2332,2340],{"className":2317},[2261],[334,2319,2320],{},[85,2321,2323],{"href":2322},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fpvs-studio","PVS-Studio",[334,2325,2326],{},[2271,2327,2329],{"className":2328},[2274],[39,2330,2331],{},"7.42",[334,2333,2334],{},[2198,2335,2336],{},[85,2337,2339],{"href":2338},"https:\u002F\u002Fpvs-studio.com\u002Fen\u002Fdocs\u002Fwarnings\u002Fv6074\u002F","V6074",[334,2341,2342],{},[950,2343],{},[317,2345,2347,2353,2359,2391],{"className":2346},[2183],[334,2348,2349],{},[85,2350,2352],{"href":2351},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fthreadsafe","ThreadSafe",[334,2354,2355],{},[2271,2356,2358],{"className":2357},[2274],"1.3",[334,2360,2361],{},[39,2362,2363,2366,2368,2371,2373,2376,2378,2381,2383,2386,2388],{},[2198,2364,2365],{},"CCE_SL_INCONSISTENT",[950,2367],{},[2198,2369,2370],{},"CCE_CC_CALLBACK_ACCESS",[950,2372],{},[2198,2374,2375],{},"CCE_SL_MIXED",[950,2377],{},[2198,2379,2380],{},"CCE_SL_INCONSISTENT_COL",[950,2382],{},[2198,2384,2385],{},"CCE_SL_MIXED_COL",[950,2387],{},[2198,2389,2390],{},"CCE_CC_UNSAFE_CONTENT",[334,2392,2257],{},[39,2394,2395],{},"Related Guidelines",[311,2397,2399],{"className":2398},[2161],[329,2400,2401],{},[317,2402,2404,2412],{"className":2403},[2183],[334,2405,2406],{},[39,2407,2408],{},[85,2409,2411],{"href":2410},"http:\u002F\u002Fcwe.mitre.org\u002F","MITRE CWE",[334,2413,2414],{},[39,2415,2416,2420,2421,2423,2427,2428,2430,2434,2435,2437,2441],{},[85,2417,2419],{"href":2418},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F366.html","CWE-366"," , Race Condition within a Thread",[950,2422],{},[85,2424,2426],{"href":2425},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F413.html","CWE-413"," , Improper Resource Locking",[950,2429],{},[85,2431,2433],{"href":2432},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F567.html","CWE-567"," , Unsynchronized Access to Shared Data in a Multithreaded Context",[950,2436],{},[85,2438,2440],{"href":2439},"http:\u002F\u002Fcwe.mitre.org\u002Fdata\u002Fdefinitions\u002F667.html","CWE-667"," , Improper Locking",[124,2443,2445],{"id":2444},"bibliography","Bibliography",[311,2447,2449,2458],{"className":2448},[2161],[2450,2451,2452,2456],"colgroup",{},[2453,2454],"col",{"style":2455},"width: 50%",[2453,2457],{"style":2455},[329,2459,2460,2484,2500,2514,2533,2568],{},[317,2461,2463,2473],{"className":2462},[2183],[334,2464,2465],{},[39,2466,2467,2468,2472],{},"[ ",[85,2469,2471],{"href":2470},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-API14","API 2014"," ]",[334,2474,2475],{},[39,2476,2477],{},[85,2478,2480,2481],{"href":2479},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002F8\u002Fdocs\u002Fapi\u002F","Class ",[43,2482,2483],{},"        AtomicInteger       ",[317,2485,2487,2495],{"className":2486},[2261],[334,2488,2489],{},[39,2490,2467,2491,2472],{},[85,2492,2494],{"href":2493},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Bloch08","Bloch 2008",[334,2496,2497],{},[39,2498,2499],{},"Item 66, \"Synchronize Access to Shared Mutable Iata\"",[317,2501,2503,2509],{"className":2502},[2183],[334,2504,2505],{},[39,2506,2467,2507,2472],{},[85,2508,1079],{"href":1078},[334,2510,2511],{},[39,2512,2513],{},"Section 2.3, \"Locking\"",[317,2515,2517,2525],{"className":2516},[2261],[334,2518,2519],{},[39,2520,2467,2521,2472],{},[85,2522,2524],{"href":2523},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-JavaTutorials","Java Tutorials",[334,2526,2527],{},[39,2528,2529],{},[85,2530,2532],{"href":2531},"http:\u002F\u002Fjava.sun.com\u002Fdocs\u002Fbooks\u002Ftutorial\u002Fessential\u002Fconcurrency\u002Findex.html","Java Concurrency Tutorial",[317,2534,2536,2542],{"className":2535},[2183],[334,2537,2538],{},[39,2539,2467,2540,2472],{},[85,2541,88],{"href":87},[334,2543,2544],{},[39,2545,2546,2550,2552,2556,2558,2562,2564],{},[85,2547,2549],{"href":2548},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002Fspecs\u002Fjls\u002Fse8\u002Fhtml\u002Fjls-17.html","Chapter 17, \"Threads and Locks\"",[950,2551],{},[85,2553,2555],{"href":2554},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002Fspecs\u002Fjls\u002Fse8\u002Fhtml\u002Fjls-17.html#jls-17.4.3","§17.4.3, \"Programs and Program Order\"",[950,2557],{},[85,2559,2561],{"href":2560},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002Fspecs\u002Fjls\u002Fse8\u002Fhtml\u002Fjls-17.html#jls-17.4.5","§17.4.5, \"Happens-before Order\"",[950,2563],{},[85,2565,2567],{"href":2566},"http:\u002F\u002Fdocs.oracle.com\u002Fjavase\u002Fspecs\u002Fjls\u002Fse8\u002Fhtml\u002Fjls-17.html#jls-17.4.8","§17.4.8, \"Executions and Causality Requirements\"",[317,2569,2571,2579],{"className":2570},[2261],[334,2572,2573],{},[39,2574,2467,2575,2472],{},[85,2576,2578],{"href":2577},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-aa-references#RuleAA.References-Lea00","Lea 2000",[334,2580,2581],{},[39,2582,2583,2584,2586],{},"Section 2.1.1.1, \"Objects and Locks\"",[950,2585],{},"\nSection 2.2.7, \"The Java Memory Model\"",[2588,2589],"hr",{},[39,2591,2592,134,2599,134,2605],{},[85,2593,2595],{"href":2594},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna01-j",[2596,2597],"img",{"src":2598},"\u002Fattachments\u002F88487702\u002F88497198.png",[85,2600,2602],{"href":2601},"\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002F",[2596,2603],{"src":2604},"\u002Fattachments\u002F88487702\u002F88497196.png",[85,2606,2607],{"href":109},[2596,2608],{"src":2609},"\u002Fattachments\u002F88487702\u002F88497197.png",[2611,2612,2613],"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 .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 .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}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 .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 .s-ngx, html code.shiki .s-ngx{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F92672}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 .sP7S_, html code.shiki .sP7S_{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#FD971F}",{"title":156,"searchDepth":181,"depth":181,"links":2615},[2616,2617,2618,2619,2620,2621,2622,2624,2625,2626,2627,2628,2629],{"id":126,"depth":181,"text":127},{"id":469,"depth":181,"text":470},{"id":591,"depth":181,"text":592},{"id":699,"depth":181,"text":700},{"id":960,"depth":181,"text":961},{"id":1083,"depth":181,"text":1084},{"id":1354,"depth":181,"text":2623},"Compliant Solution ( AtomicBoolean )",{"id":1540,"depth":181,"text":1541},{"id":1758,"depth":181,"text":1759},{"id":1936,"depth":181,"text":1937},{"id":2084,"depth":181,"text":2085},{"id":2151,"depth":181,"text":2152},{"id":2444,"depth":181,"text":2445},"Compound operations are operations that consist of more than one discrete operation. Expressions that include postfix or prefix increment ( ++ ), postfix or prefix decrement ( -- ), or compound assignment operators always result in compound operations. Compound assignment expressions use operators such as *= , \u002F= , %= , += , -= , \u003C\u003C= , >>= , >>>= , ^= and |= [ JLS 2015 ]. Compound operations on shared variables must be performed atomically to prevent data races and race conditions .","md",{"tags":2633},[2634,2635,2636,2637,2638],"android-applicable","vna","android","cwe-362","rule","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fvisibility-and-atomicity-vna\u002Fvna02-j",{"title":30,"description":2630},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F4.vna02-j","wszf5wD95lmdhJsBzHfiTf95M-CVlOYlyMWe929cqu4",[2644,2647],{"title":2645,"path":2594,"stem":2646,"children":-1},"VNA01-J. Ensure visibility of shared references to immutable objects","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F3.vna01-j",{"title":110,"path":109,"stem":2648,"children":-1},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F5.vna03-j",[2650],{"title":2651,"path":2652,"stem":2653,"children":2654},"SEI CERT Oracle Coding Standard for Java","\u002Fsei-cert-oracle-coding-standard-for-java","6.sei-cert-oracle-coding-standard-for-java\u002F1.index",[2655,2656,2796,3619,4018,4185],{"title":2651,"path":2652,"stem":2653},{"title":2657,"path":2658,"stem":2659,"children":2660},"Front Matter","\u002Fsei-cert-oracle-coding-standard-for-java\u002Ffront-matter","6.sei-cert-oracle-coding-standard-for-java\u002F2.front-matter\u002F1.index",[2661,2662,2666,2670,2674,2720,2758],{"title":2657,"path":2658,"stem":2659},{"title":2663,"path":2664,"stem":2665},"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":2667,"path":2668,"stem":2669},"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":2671,"path":2672,"stem":2673},"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":2675,"path":2676,"stem":2677,"children":2678},"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",[2679,2680,2684,2688,2692,2696,2700,2704,2708,2712,2716],{"title":2675,"path":2676,"stem":2677},{"title":2681,"path":2682,"stem":2683},"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":2685,"path":2686,"stem":2687},"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":2689,"path":2690,"stem":2691},"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":2693,"path":2694,"stem":2695},"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":2697,"path":2698,"stem":2699},"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":2701,"path":2702,"stem":2703},"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":2705,"path":2706,"stem":2707},"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":2709,"path":2710,"stem":2711},"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":2713,"path":2714,"stem":2715},"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":2717,"path":2718,"stem":2719},"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":2721,"path":2722,"stem":2723,"children":2724},"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",[2725,2726,2730,2734,2738,2742,2746,2750,2754],{"title":2721,"path":2722,"stem":2723},{"title":2727,"path":2728,"stem":2729},"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":2731,"path":2732,"stem":2733},"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":2735,"path":2736,"stem":2737},"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":2739,"path":2740,"stem":2741},"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":2743,"path":2744,"stem":2745},"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":2747,"path":2748,"stem":2749},"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":2751,"path":2752,"stem":2753},"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":2755,"path":2756,"stem":2757},"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":2759,"path":2760,"stem":2761,"children":2762},"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",[2763,2764,2767,2770,2773,2777,2780,2783,2786,2789,2793],{"title":2759,"path":2760,"stem":2761},{"title":2681,"path":2765,"stem":2766},"\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":2685,"path":2768,"stem":2769},"\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":2689,"path":2771,"stem":2772},"\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":2774,"path":2775,"stem":2776},"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":2697,"path":2778,"stem":2779},"\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":2701,"path":2781,"stem":2782},"\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":2705,"path":2784,"stem":2785},"\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":2709,"path":2787,"stem":2788},"\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":2790,"path":2791,"stem":2792},"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":2717,"path":2794,"stem":2795},"\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":2797,"path":2798,"stem":2799,"children":2800},"Rules","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F01.index",[2801,2802,2806,2832,2850,2896,2934,3008,3062,3088,3140,3202,3256,3312,3374,3424,3464,3522,3552,3578,3600],{"title":2797,"path":2798,"stem":2799},{"title":2803,"path":2804,"stem":2805},"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":2807,"path":2808,"stem":2809,"children":2810},"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",[2811,2812,2816,2820,2824,2828],{"title":2807,"path":2808,"stem":2809},{"title":2813,"path":2814,"stem":2815},"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":2817,"path":2818,"stem":2819},"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":2821,"path":2822,"stem":2823},"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":2825,"path":2826,"stem":2827},"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":2829,"path":2830,"stem":2831},"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":2833,"path":2834,"stem":2835,"children":2836},"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",[2837,2838,2842,2846],{"title":2833,"path":2834,"stem":2835},{"title":2839,"path":2840,"stem":2841},"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":2843,"path":2844,"stem":2845},"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":2847,"path":2848,"stem":2849},"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":2851,"path":2852,"stem":2853,"children":2854},"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",[2855,2856,2860,2864,2868,2872,2876,2880,2884,2888,2892],{"title":2851,"path":2852,"stem":2853},{"title":2857,"path":2858,"stem":2859},"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":2861,"path":2862,"stem":2863},"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":2865,"path":2866,"stem":2867},"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":2869,"path":2870,"stem":2871},"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":2873,"path":2874,"stem":2875},"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":2877,"path":2878,"stem":2879},"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":2881,"path":2882,"stem":2883},"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":2885,"path":2886,"stem":2887},"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":2889,"path":2890,"stem":2891},"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":2893,"path":2894,"stem":2895},"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":2897,"path":2898,"stem":2899,"children":2900},"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",[2901,2902,2906,2910,2914,2918,2922,2926,2930],{"title":2897,"path":2898,"stem":2899},{"title":2903,"path":2904,"stem":2905},"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":2907,"path":2908,"stem":2909},"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":2911,"path":2912,"stem":2913},"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":2915,"path":2916,"stem":2917},"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":2919,"path":2920,"stem":2921},"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":2923,"path":2924,"stem":2925},"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":2927,"path":2928,"stem":2929},"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":2931,"path":2932,"stem":2933},"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":2935,"path":2936,"stem":2937,"children":2938},"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",[2939,2940,2944,2948,2952,2956,2960,2964,2968,2972,2976,2980,2984,2988,2992,2996,3000,3004],{"title":2935,"path":2936,"stem":2937},{"title":2941,"path":2942,"stem":2943},"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":2945,"path":2946,"stem":2947},"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":2949,"path":2950,"stem":2951},"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":2953,"path":2954,"stem":2955},"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":2957,"path":2958,"stem":2959},"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":2961,"path":2962,"stem":2963},"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":2965,"path":2966,"stem":2967},"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":2969,"path":2970,"stem":2971},"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":2973,"path":2974,"stem":2975},"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":2977,"path":2978,"stem":2979},"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":2981,"path":2982,"stem":2983},"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":2985,"path":2986,"stem":2987},"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":2989,"path":2990,"stem":2991},"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":2993,"path":2994,"stem":2995},"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":2997,"path":2998,"stem":2999},"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":3001,"path":3002,"stem":3003},"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":3005,"path":3006,"stem":3007},"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":3009,"path":3010,"stem":3011,"children":3012},"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",[3013,3014,3018,3022,3026,3030,3034,3038,3042,3046,3050,3054,3058],{"title":3009,"path":3010,"stem":3011},{"title":3015,"path":3016,"stem":3017},"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":3019,"path":3020,"stem":3021},"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":3023,"path":3024,"stem":3025},"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":3027,"path":3028,"stem":3029},"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":3031,"path":3032,"stem":3033},"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":3035,"path":3036,"stem":3037},"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":3039,"path":3040,"stem":3041},"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":3043,"path":3044,"stem":3045},"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":3047,"path":3048,"stem":3049},"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":3051,"path":3052,"stem":3053},"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":3055,"path":3056,"stem":3057},"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":3059,"path":3060,"stem":3061},"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":3063,"path":3064,"stem":3065,"children":3066},"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",[3067,3068,3072,3076,3080,3084],{"title":3063,"path":3064,"stem":3065},{"title":3069,"path":3070,"stem":3071},"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":3073,"path":3074,"stem":3075},"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":3077,"path":3078,"stem":3079},"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":3081,"path":3082,"stem":3083},"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":3085,"path":3086,"stem":3087},"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":3089,"path":3090,"stem":3091,"children":3092},"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",[3093,3094,3096,3100,3104,3108,3112,3116,3120,3124,3128,3132,3136],{"title":3089,"path":3090,"stem":3091},{"title":956,"path":955,"stem":3095},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F10.locking-lck\u002F02.lck00-j",{"title":3097,"path":3098,"stem":3099},"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":3101,"path":3102,"stem":3103},"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":3105,"path":3106,"stem":3107},"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":3109,"path":3110,"stem":3111},"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":3113,"path":3114,"stem":3115},"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":3117,"path":3118,"stem":3119},"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":3121,"path":3122,"stem":3123},"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":3125,"path":3126,"stem":3127},"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":3129,"path":3130,"stem":3131},"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":3133,"path":3134,"stem":3135},"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":3137,"path":3138,"stem":3139},"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":3141,"path":3142,"stem":3143,"children":3144},"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",[3145,3146,3150,3154,3158,3162,3166,3170,3174,3178,3182,3186,3190,3194,3198],{"title":3141,"path":3142,"stem":3143},{"title":3147,"path":3148,"stem":3149},"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":3151,"path":3152,"stem":3153},"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":3155,"path":3156,"stem":3157},"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":3159,"path":3160,"stem":3161},"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":3163,"path":3164,"stem":3165},"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":3167,"path":3168,"stem":3169},"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":3171,"path":3172,"stem":3173},"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":3175,"path":3176,"stem":3177},"MET07-J. Never declare a class method that hides a method declared in a superclass or superinterface","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet07-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F09.met07-j",{"title":3179,"path":3180,"stem":3181},"MET08-J. Preserve the equality contract when overriding the equals() method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet08-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F10.met08-j",{"title":3183,"path":3184,"stem":3185},"MET09-J. Classes that define an equals() method must also define a hashCode() method","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frules\u002Fmethods-met\u002Fmet09-j","6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F11.methods-met\u002F11.met09-j",{"title":3187,"path":3188,"stem":3189},"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":3191,"path":3192,"stem":3193},"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":3195,"path":3196,"stem":3197},"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":3199,"path":3200,"stem":3201},"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":3203,"path":3204,"stem":3205,"children":3206},"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",[3207,3208,3212,3216,3220,3224,3228,3232,3236,3240,3244,3248,3252],{"title":3203,"path":3204,"stem":3205},{"title":3209,"path":3210,"stem":3211},"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":3213,"path":3214,"stem":3215},"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":3217,"path":3218,"stem":3219},"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":3221,"path":3222,"stem":3223},"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":3225,"path":3226,"stem":3227},"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":3229,"path":3230,"stem":3231},"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":3233,"path":3234,"stem":3235},"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":3237,"path":3238,"stem":3239},"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":3241,"path":3242,"stem":3243},"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":3245,"path":3246,"stem":3247},"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":3249,"path":3250,"stem":3251},"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":3253,"path":3254,"stem":3255},"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":3257,"path":3258,"stem":3259,"children":3260},"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",[3261,3262,3264,3268,3272,3276,3280,3284,3288,3292,3296,3300,3304,3308],{"title":3257,"path":3258,"stem":3259},{"title":1565,"path":1564,"stem":3263},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F13.numeric-types-and-operations-num\u002F02.num00-j",{"title":3265,"path":3266,"stem":3267},"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":3269,"path":3270,"stem":3271},"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":3273,"path":3274,"stem":3275},"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":3277,"path":3278,"stem":3279},"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":3281,"path":3282,"stem":3283},"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":3285,"path":3286,"stem":3287},"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":3289,"path":3290,"stem":3291},"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":3293,"path":3294,"stem":3295},"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":3297,"path":3298,"stem":3299},"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":3301,"path":3302,"stem":3303},"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":3305,"path":3306,"stem":3307},"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":3309,"path":3310,"stem":3311},"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":3313,"path":3314,"stem":3315,"children":3316},"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",[3317,3318,3322,3326,3330,3334,3338,3342,3346,3350,3354,3358,3362,3366,3370],{"title":3313,"path":3314,"stem":3315},{"title":3319,"path":3320,"stem":3321},"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":3323,"path":3324,"stem":3325},"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":3327,"path":3328,"stem":3329},"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":3331,"path":3332,"stem":3333},"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":3335,"path":3336,"stem":3337},"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":3339,"path":3340,"stem":3341},"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":3343,"path":3344,"stem":3345},"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":3347,"path":3348,"stem":3349},"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":3351,"path":3352,"stem":3353},"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":3355,"path":3356,"stem":3357},"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":3359,"path":3360,"stem":3361},"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":3363,"path":3364,"stem":3365},"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":3367,"path":3368,"stem":3369},"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":3371,"path":3372,"stem":3373},"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":3375,"path":3376,"stem":3377,"children":3378},"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",[3379,3380,3384,3388,3392,3396,3400,3404,3408,3412,3416,3420],{"title":3375,"path":3376,"stem":3377},{"title":3381,"path":3382,"stem":3383},"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":3385,"path":3386,"stem":3387},"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":3389,"path":3390,"stem":3391},"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":3393,"path":3394,"stem":3395},"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":3397,"path":3398,"stem":3399},"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":3401,"path":3402,"stem":3403},"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":3405,"path":3406,"stem":3407},"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":3409,"path":3410,"stem":3411},"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":3413,"path":3414,"stem":3415},"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":3417,"path":3418,"stem":3419},"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":3421,"path":3422,"stem":3423},"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":3425,"path":3426,"stem":3427,"children":3428},"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",[3429,3430,3434,3438,3442,3452,3456,3460],{"title":3425,"path":3426,"stem":3427},{"title":3431,"path":3432,"stem":3433},"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":3435,"path":3436,"stem":3437},"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":3439,"path":3440,"stem":3441},"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":3443,"path":3444,"stem":3445,"children":3446},"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",[3447,3448],{"title":3443,"path":3444,"stem":3445},{"title":3449,"path":3450,"stem":3451},"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":3453,"path":3454,"stem":3455},"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":3457,"path":3458,"stem":3459},"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":3461,"path":3462,"stem":3463},"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":3465,"path":3466,"stem":3467,"children":3468},"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",[3469,3470,3474,3478,3482,3486,3490,3494,3498,3502,3506,3510,3514,3518],{"title":3465,"path":3466,"stem":3467},{"title":3471,"path":3472,"stem":3473},"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":3475,"path":3476,"stem":3477},"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":3479,"path":3480,"stem":3481},"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":3483,"path":3484,"stem":3485},"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":3487,"path":3488,"stem":3489},"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":3491,"path":3492,"stem":3493},"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":3495,"path":3496,"stem":3497},"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":3499,"path":3500,"stem":3501},"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":3503,"path":3504,"stem":3505},"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":3507,"path":3508,"stem":3509},"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":3511,"path":3512,"stem":3513},"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":3515,"path":3516,"stem":3517},"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":3519,"path":3520,"stem":3521},"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":3523,"path":3524,"stem":3525,"children":3526},"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",[3527,3528,3532,3536,3540,3544,3548],{"title":3523,"path":3524,"stem":3525},{"title":3529,"path":3530,"stem":3531},"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":3533,"path":3534,"stem":3535},"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":3537,"path":3538,"stem":3539},"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":3541,"path":3542,"stem":3543},"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":3545,"path":3546,"stem":3547},"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":3549,"path":3550,"stem":3551},"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":3553,"path":3554,"stem":3555,"children":3556},"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",[3557,3558,3562,3566,3570,3574],{"title":3553,"path":3554,"stem":3555},{"title":3559,"path":3560,"stem":3561},"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":3563,"path":3564,"stem":3565},"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":3567,"path":3568,"stem":3569},"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":3571,"path":3572,"stem":3573},"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":3575,"path":3576,"stem":3577},"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":3579,"path":3580,"stem":3581,"children":3582},"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",[3583,3584,3588,3592,3596],{"title":3579,"path":3580,"stem":3581},{"title":3585,"path":3586,"stem":3587},"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":3589,"path":3590,"stem":3591},"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":3593,"path":3594,"stem":3595},"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":3597,"path":3598,"stem":3599},"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":3601,"path":3602,"stem":3603,"children":3604},"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",[3605,3606,3610,3611,3612,3613,3617],{"title":3601,"path":3602,"stem":3603},{"title":3607,"path":3608,"stem":3609},"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":2645,"path":2594,"stem":2646},{"title":30,"path":2639,"stem":2641},{"title":110,"path":109,"stem":2648},{"title":3614,"path":3615,"stem":3616},"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":121,"path":120,"stem":3618},"6.sei-cert-oracle-coding-standard-for-java\u002F3.rules\u002F21.visibility-and-atomicity-vna\u002F7.vna05-j",{"title":3620,"path":3621,"stem":3622,"children":3623},"Recommendations","\u002Fsei-cert-oracle-coding-standard-for-java\u002Frecommendations","6.sei-cert-oracle-coding-standard-for-java\u002F4.recommendations\u002F01.index",[3624,3625,3638,3656,3709,3734,3763,3784,3817,3850,3911,3936,3977],{"title":3620,"path":3621,"stem":3622},{"title":2807,"path":3626,"stem":3627,"children":3628},"\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",[3629,3630,3634],{"title":2807,"path":3626,"stem":3627},{"title":3631,"path":3632,"stem":3633},"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":3635,"path":3636,"stem":3637},"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":3639,"path":3640,"stem":3641,"children":3642},"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",[3643,3644,3648,3652],{"title":3639,"path":3640,"stem":3641},{"title":3645,"path":3646,"stem":3647},"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":3649,"path":3650,"stem":3651},"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":3653,"path":3654,"stem":3655},"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":2833,"path":3657,"stem":3658,"children":3659},"\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",[3660,3661,3665,3669,3673,3677,3681,3685,3689,3693,3697,3701,3705],{"title":2833,"path":3657,"stem":3658},{"title":3662,"path":3663,"stem":3664},"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":3666,"path":3667,"stem":3668},"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":3670,"path":3671,"stem":3672},"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":3674,"path":3675,"stem":3676},"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":3678,"path":3679,"stem":3680},"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":3682,"path":3683,"stem":3684},"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":3686,"path":3687,"stem":3688},"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":3690,"path":3691,"stem":3692},"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":3694,"path":3695,"stem":3696},"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":3698,"path":3699,"stem":3700},"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":3702,"path":3703,"stem":3704},"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":3706,"path":3707,"stem":3708},"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":2851,"path":3710,"stem":3711,"children":3712},"\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",[3713,3714,3718,3722,3726,3730],{"title":2851,"path":3710,"stem":3711},{"title":3715,"path":3716,"stem":3717},"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":3719,"path":3720,"stem":3721},"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":3723,"path":3724,"stem":3725},"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":3727,"path":3728,"stem":3729},"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":3731,"path":3732,"stem":3733},"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":2897,"path":3735,"stem":3736,"children":3737},"\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",[3738,3739,3743,3747,3751,3755,3759],{"title":2897,"path":3735,"stem":3736},{"title":3740,"path":3741,"stem":3742},"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":3744,"path":3745,"stem":3746},"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":3748,"path":3749,"stem":3750},"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":3752,"path":3753,"stem":3754},"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":3756,"path":3757,"stem":3758},"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":3760,"path":3761,"stem":3762},"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":2935,"path":3764,"stem":3765,"children":3766},"\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",[3767,3768,3772,3776,3780],{"title":2935,"path":3764,"stem":3765},{"title":3769,"path":3770,"stem":3771},"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":3773,"path":3774,"stem":3775},"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":3777,"path":3778,"stem":3779},"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":3781,"path":3782,"stem":3783},"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":3009,"path":3785,"stem":3786,"children":3787},"\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",[3788,3789,3793,3797,3801,3805,3809,3813],{"title":3009,"path":3785,"stem":3786},{"title":3790,"path":3791,"stem":3792},"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":3794,"path":3795,"stem":3796},"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":3798,"path":3799,"stem":3800},"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":3802,"path":3803,"stem":3804},"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":3806,"path":3807,"stem":3808},"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":3810,"path":3811,"stem":3812},"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":3814,"path":3815,"stem":3816},"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":3141,"path":3818,"stem":3819,"children":3820},"\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",[3821,3822,3826,3830,3834,3838,3842,3846],{"title":3141,"path":3818,"stem":3819},{"title":3823,"path":3824,"stem":3825},"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":3827,"path":3828,"stem":3829},"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":3831,"path":3832,"stem":3833},"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":3835,"path":3836,"stem":3837},"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":3839,"path":3840,"stem":3841},"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":3843,"path":3844,"stem":3845},"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":3847,"path":3848,"stem":3849},"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":3203,"path":3851,"stem":3852,"children":3853},"\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",[3854,3855,3859,3863,3867,3871,3875,3879,3883,3887,3891,3895,3899,3903,3907],{"title":3203,"path":3851,"stem":3852},{"title":3856,"path":3857,"stem":3858},"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":3860,"path":3861,"stem":3862},"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":3864,"path":3865,"stem":3866},"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":3868,"path":3869,"stem":3870},"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":3872,"path":3873,"stem":3874},"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":3876,"path":3877,"stem":3878},"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":3880,"path":3881,"stem":3882},"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":3884,"path":3885,"stem":3886},"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":3888,"path":3889,"stem":3890},"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":3892,"path":3893,"stem":3894},"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":3896,"path":3897,"stem":3898},"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":3900,"path":3901,"stem":3902},"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":3904,"path":3905,"stem":3906},"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":3908,"path":3909,"stem":3910},"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":3257,"path":3912,"stem":3913,"children":3914},"\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",[3915,3916,3920,3924,3928,3932],{"title":3257,"path":3912,"stem":3913},{"title":3917,"path":3918,"stem":3919},"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":3921,"path":3922,"stem":3923},"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":3925,"path":3926,"stem":3927},"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":3929,"path":3930,"stem":3931},"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":3933,"path":3934,"stem":3935},"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":3313,"path":3937,"stem":3938,"children":3939},"\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",[3940,3941,3945,3949,3953,3957,3961,3965,3969,3973],{"title":3313,"path":3937,"stem":3938},{"title":3942,"path":3943,"stem":3944},"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":3946,"path":3947,"stem":3948},"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":3950,"path":3951,"stem":3952},"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":3954,"path":3955,"stem":3956},"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":3958,"path":3959,"stem":3960},"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":3962,"path":3963,"stem":3964},"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":3966,"path":3967,"stem":3968},"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":3970,"path":3971,"stem":3972},"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":3974,"path":3975,"stem":3976},"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":3375,"path":3978,"stem":3979,"children":3980},"\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",[3981,3982,3986,3990,3994,3998,4002,4006,4010,4014],{"title":3375,"path":3978,"stem":3979},{"title":3983,"path":3984,"stem":3985},"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":3987,"path":3988,"stem":3989},"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":3991,"path":3992,"stem":3993},"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":3995,"path":3996,"stem":3997},"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":3999,"path":4000,"stem":4001},"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":4003,"path":4004,"stem":4005},"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":4007,"path":4008,"stem":4009},"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":4011,"path":4012,"stem":4013},"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":4015,"path":4016,"stem":4017},"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":4019,"path":4020,"stem":4021,"children":4022},"Back Matter","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F1.index",[4023,4024,4028,4032,4036,4039,4156,4181],{"title":4019,"path":4020,"stem":4021},{"title":4025,"path":4026,"stem":4027},"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":4029,"path":4030,"stem":4031},"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":4033,"path":4034,"stem":4035},"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":4037,"path":104,"stem":4038},"Rule BB. Glossary","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F5.rule-bb-glossary",{"title":4040,"path":4041,"stem":4042,"children":4043},"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",[4044,4045,4049,4053,4055,4059,4063,4067,4071,4075,4079,4083,4087,4091,4093,4097,4100,4104,4108,4112,4114,4118,4122,4126,4130,4134,4138,4142,4146,4150,4152],{"title":4040,"path":4041,"stem":4042},{"title":4046,"path":4047,"stem":4048},"CodeSonar","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fcodesonar","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F02.codesonar",{"title":4050,"path":4051,"stem":4052},"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":2189,"path":2188,"stem":4054},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F04.coverity",{"title":4056,"path":4057,"stem":4058},"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":4060,"path":4061,"stem":4062},"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":4064,"path":4065,"stem":4066},"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":4068,"path":4069,"stem":4070},"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":4072,"path":4073,"stem":4074},"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":4076,"path":4077,"stem":4078},"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":4080,"path":4081,"stem":4082},"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":4084,"path":4085,"stem":4086},"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":4088,"path":4089,"stem":4090},"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":2267,"path":2266,"stem":4092},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F14.klocwork",{"title":4094,"path":4095,"stem":4096},"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":4098,"path":2294,"stem":4099},"Parasoft","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F16.parasoft",{"title":4101,"path":4102,"stem":4103},"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":4105,"path":4106,"stem":4107},"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":4109,"path":4110,"stem":4111},"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":2323,"path":2322,"stem":4113},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F20.pvs-studio",{"title":4115,"path":4116,"stem":4117},"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":4119,"path":4120,"stem":4121},"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":4123,"path":4124,"stem":4125},"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":4127,"path":4128,"stem":4129},"SonarQube","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fback-matter\u002Frule-or-rec-cc-analyzers\u002Fsonarqube","6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F24.sonarqube",{"title":4131,"path":4132,"stem":4133},"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":4135,"path":4136,"stem":4137},"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":4139,"path":4140,"stem":4141},"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":4143,"path":4144,"stem":4145},"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":4147,"path":4148,"stem":4149},"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":2352,"path":2351,"stem":4151},"6.sei-cert-oracle-coding-standard-for-java\u002F5.back-matter\u002F6.rule-or-rec-cc-analyzers\u002F30.threadsafe",{"title":4153,"path":4154,"stem":4155},"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":4157,"path":4158,"stem":4159,"children":4160},"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",[4161,4162,4166,4170,4174,4177],{"title":4157,"path":4158,"stem":4159},{"title":4163,"path":4164,"stem":4165},"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":4167,"path":4168,"stem":4169},"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":4171,"path":4172,"stem":4173},"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":2411,"path":4175,"stem":4176},"\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":4178,"path":4179,"stem":4180},"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":4182,"path":4183,"stem":4184},"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":4186,"path":4187,"stem":4188,"children":4189},"Admin","\u002Fsei-cert-oracle-coding-standard-for-java\u002Fadmin","6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F1.index",[4190,4191,4195,4199,4203,4207],{"title":4186,"path":4187,"stem":4188},{"title":4192,"path":4193,"stem":4194},"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":4196,"path":4197,"stem":4198},"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":4200,"path":4201,"stem":4202},"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":4204,"path":4205,"stem":4206},"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":4204,"path":4205,"stem":4208},"6.sei-cert-oracle-coding-standard-for-java\u002F6.admin\u002F6.todo-list",1775657817696]