fix stringlengths 2 833 | ctx stringlengths 80 394k |
|---|---|
if(cnay != null){ | [BUG] if(y[0] <= ycycleBound) {[ERROR] null testDrawWithNullInfo [CONTEXT] super.drawItem(g2, state, dataArea, info, plot, domainAxis, rangeAxis, dataset, series, item, crosshairState, pass); return; } OverwriteDataSet newset = new OverwriteDataSet(x, y, dataset); if(cnax != null) { if(xcycleBound == x[0]) { cnax.setBoundMappedToLastCycle(x[1] <= xcycleBound); } if(xcycleBound == x[1]) { cnax.setBoundMappedToLastCycle(x[0] <= xcycleBound); } } <extra_id_0> if(ycycleBound == y[0]) { cnay.setBoundMappedToLastCycle(y[1] <= ycycleBound); } if(ycycleBound == y[1]) { cnay.setBoundMappedToLastCycle(y[0] <= ycycleBound); } } super.drawItem( g2, state, dataArea, info, plot, domainAxis, rangeAxis, newset, series, 1, crosshairState, pass); if(cnax != null) { if(xcycleBound == x[1]) { cnax.setBoundMappedToLastCycle(x[2] <= xcycleBound); [CLASS] CyclicXYItemRenderer OverwriteDataSet [METHOD] drawItem [RETURN_TYPE] void Graphics2D g2 XYItemRendererState state Rectangle2D dataArea PlotRenderingInfo info XYPlot plot ValueAxis domainAxis ValueAxis rangeAxis XYDataset dataset int series int item CrosshairState crosshairState int pass [VARIABLES] PlotRenderingInfo info double xcycleBound xn ycycleBound yn CyclicNumberAxis cnax cnay Rectangle2D dataArea CrosshairState crosshairState OverwriteDataSet newset long serialVersionUID int item pass series Graphics2D g2 Double[] x y boolean xBoundMapping yBoundMapping XYPlot plot double[] nx ny x y ValueAxis domainAxis rangeAxis XYDataset dataset delegateSet XYItemRendererState state |
sb.append(":"); | [BUG] sb.append( str);sb.append(":");[ERROR] null testAliasThrowKeywordLiteral [CONTEXT] private void outputStringUsage() { StringBuilder sb = new StringBuilder("Strings used more than once:\n"); for(String str : stringInfoMap.keySet()) { StringInfo info = stringInfoMap.get(str); if(info.numOccurrences > 1) { sb.append(info.numOccurrences); <extra_id_0> sb.append(str); sb.append('\n'); } } logger.info(sb.toString()); } [CLASS] AliasStrings StringOccurrence StringInfo [METHOD] outputStringUsage [RETURN_TYPE] void [VARIABLES] Set aliasableStrings strings usedHashedAliases StringBuilder sb Matcher blacklist Node ancestor externs n name node parent parentForNewVarDecl prev root siblingToInsertVarDeclBefore value var varParent String STRING_ALIAS_PREFIX alias aliasName blacklistRegex literal name str string Logger logger JSModuleGraph moduleGraph long unitTestHashReductionMask int id numOccurrences numOccurrencesInfrequentlyExecuted sizeOfAliases sizeOfLiteral sizeOfStrings sizeOfVariable AbstractCompiler compiler boolean isAliased outputStringUsage StringInfo info JSModule module moduleToContainDecl List occurrences Map moduleVarParentMap stringInfoMap |
DeserializationConfig cfg = getDeserializationConfig();_deserializationConfig = _deserializationConfig.with( f); | [BUG] _deserializationConfig = _deserializationConfig.with(f); [CONTEXT] public ObjectMapper setTypeFactory(TypeFactory f) { _typeFactory = f; <extra_id_0> _serializationConfig = _serializationConfig.with(f); return this; } [CLASS] ObjectMapper DefaultTyping DefaultTypeResolverBuilder 1 [METHOD] setTypeFactory [RETURN_TYPE] ObjectMapper TypeFactory f [VARIABLES] RootNameLookup _rootNames SerializerFactory _serializerFactory f DefaultDeserializationContext _deserializationContext dc SubtypeResolver _subtypeResolver str HashMap _mixInAnnotations mixins SerializationConfig _serializationConfig config DefaultSerializerProvider _serializerProvider p sp AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR ai deserializerAI serializerAI JsonFactory _jsonFactory jf DeserializationConfig _deserializationConfig config InjectableValues _injectableValues long serialVersionUID ClassIntrospector DEFAULT_INTROSPECTOR ci JavaType JSON_NODE_TYPE baseType t PrettyPrinter _defaultPrettyPrinter boolean VisibilityChecker STD_VISIBILITY_CHECKER vc BaseSettings DEFAULT_BASE DefaultTyping JAVA_LANG_OBJECT NON_CONCRETE_AND_ARRAYS NON_FINAL OBJECT_AND_NON_CONCRETE _appliesFor applicability dti t TypeFactory _typeFactory f ConcurrentHashMap _rootDeserializers |
if(_inputStart >= 0){ | [BUG] if(start == 0) {[ERROR] expected:<393218> but was:<393217> testLongAppend [CONTEXT] } _resultString = null; _resultArray = null; char[] curr = _currentSegment; if(_currentSize >= curr.length) { expand(1); curr = _currentSegment; } curr[_currentSize++] = c; } public void append(char[] c, int start, int len) { <extra_id_0> unshare(len); } _resultString = null; _resultArray = null; char[] curr = _currentSegment; int max = curr.length - _currentSize; if(max >= len) { System.arraycopy(c, start, curr, _currentSize, len); _currentSize += len; return; } [CLASS] TextBuffer [METHOD] append [RETURN_TYPE] void char[] c int start int len [VARIABLES] boolean _hasSegments BufferRecycler _allocator allocator ArrayList _segments String _resultString value int MAX_SEGMENT_LEN MIN_SEGMENT_LEN _currentSize _inputLen _inputStart _segmentSize amount currLen i len max needed segLen start char[] NO_CHARS _currentSegment _inputBuffer _resultArray buf c curr result |
return delegate.indexOfThrowable(type, 0); | [BUG] return delegate.indexOfThrowable( type, -4);[NO-ERROR] [CONTEXT] public int indexOfThrowable(Class type) { <extra_id_0> } [CLASS] NestableException [METHOD] indexOfThrowable [RETURN_TYPE] int Class type [VARIABLES] Throwable cause Class type boolean NestableDelegate delegate |
} else if(length > 1){ | [BUG] } else if(accum -(pow( accum2, 2))/(( double)(length))) {[ERROR] cannot find symbol accum [CONTEXT] public double evaluate(final double[] values, final double mean, final int begin, final int length) { double var = Double.NaN; if(test(values, begin, length)) { if(length == 1) { var = 0.0; <extra_id_0> double accum = 0.0; double accum2 = 0.0; for(int i = begin; i < begin + length; i++) { accum += Math.pow((values[i] - mean), 2.0); accum2 +=(values[i] - mean); } if(isBiasCorrected) { var =(accum -(Math.pow(accum2, 2) /((double) length))) /(double)(length - 1); } else { var =(accum -(Math.pow(accum2, 2) /((double) length))) /(double) length; } } } return var; } [CLASS] Variance [METHOD] evaluate [RETURN_TYPE] double final double[] values final double mean final int begin final int length [VARIABLES] boolean incMoment isBiasCorrected double[] values long serialVersionUID SecondMoment m2 moment double accum accum2 mean var int begin i length |
checkProvides = CheckLevel.OFF; | [BUG] checkProvides = null;[ERROR] null testAliasThrowKeywordLiteral [CONTEXT] checkMethods = CheckLevel.OFF; checkDuplicateMessages = false; allowLegacyJsMessages = false; strictMessageReplacement = false; checkSuspiciousCode = false; checkControlStructures = false; checkUndefinedProperties = CheckLevel.OFF; checkUnusedPropertiesEarly = false; checkTypes = false; tightenTypes = false; inferTypesInGlobalScope = false; checkTypedPropertyCalls = false; reportMissingOverride = CheckLevel.OFF; reportUnknownTypes = CheckLevel.OFF; checkRequires = CheckLevel.OFF; <extra_id_0> checkGlobalNamesLevel = CheckLevel.OFF; brokenClosureRequiresLevel = CheckLevel.ERROR; checkGlobalThisLevel = CheckLevel.WARNING; checkUnreachableCode = CheckLevel.OFF; checkMissingReturn = CheckLevel.OFF; checkMissingGetCssNameLevel = CheckLevel.OFF; checkMissingGetCssNameBlacklist = null; checkEs5Strict = false; checkCaja = false; computeFunctionSideEffects = false; chainCalls = false; foldConstants = false; removeConstantExpressions = false; [CLASS] CompilerOptions DevMode TracerMode [METHOD] <init> [RETURN_TYPE] CompilerOptions() [VARIABLES] ErrorFormat errorFormat TracerMode ALL FAST OFF tracer Set aliasableStrings idGenerators stripNamePrefixes stripNameSuffixes stripTypePrefixes stripTypes CssRenamingMap cssRenamingMap CheckLevel aggressiveVarCheck brokenClosureRequiresLevel checkFunctions checkGlobalNamesLevel checkGlobalThisLevel checkMethods checkMissingGetCssNameLevel checkMissingReturn checkProvides checkRequires checkShadowVars checkUndefinedProperties checkUnreachableCode reportMissingOverride reportUnknownTypes PropertyRenamingPolicy propertyRenaming AnonymousFunctionNamingPolicy anonymousFunctionNaming Charset outputCharset String aliasStringsBlacklist aliasableGlobals appNameStr checkMissingGetCssNameBlacklist debugFunctionSideEffectsPath externExportsPath instrumentationTemplate jsOutputFile locale nameReferenceGraphPath nameReferenceReportPath renamePrefix reportPath sourceMapOutputPath syntheticBlockEndMarker syntheticBlockStartMarker unaliasableGlobals VariableRenamingPolicy variableRenaming long serialVersionUID byte[] inputPropertyMapSerialized inputVariableMapSerialized Multimap customPasses boolean aliasAllStrings aliasExternals aliasKeywords allowLegacyJsMessages ambiguateProperties chainCalls checkCaja checkControlStructures checkDuplicateMessages checkEs5Strict checkSuspiciousCode checkSymbols checkTypedPropertyCalls checkTypes checkUnusedPropertiesEarly closurePass coalesceVariableNames collapseAnonymousFunctions collapseProperties collapsePropertiesOnExternTypes collapseVariableDeclarations colorizeErrorOutput computeFunctionSideEffects convertToDottedProperties crossModuleCodeMotion crossModuleMethodMotion deadAssignmentElimination decomposeExpressions devirtualizePrototypeMethods disambiguateProperties exportTestFunctions extractPrototypeMemberDeclarations flowSensitiveInlineVariables foldConstants gatherCssNames generateExports generatePseudoNames ideMode ignoreCajaProperties inferTypesInGlobalScope inlineAnonymousFunctionExpressions inlineConstantVars inlineFunctions inlineGetters inlineLocalFunctions inlineLocalVariables inlineVariables instrumentForCoverage instrumentForCoverageOnly labelRenaming lineBreak markAsCompiled markNoSideEffectCalls moveFunctionDeclarations nameAnonymousFunctionsOnly optimizeArgumentsArray optimizeParameters outputJsStringUsage prettyPrint printInputDelimiter processObjectPropertyString recordFunctionInformation removeAbstractMethods removeConstantExpressions removeDeadCode removeEmptyFunctions removeTryCatchFinally removeUnusedPrototypeProperties removeUnusedPrototypePropertiesInExterns removeUnusedVars removeUnusedVarsInGlobalScope reserveRawExports rewriteFunctionExpressions rewriteNewDateGoogNow skipAllPasses smartNameRemoval strictMessageReplacement tightenTypes ComposeWarningsGuard warningsGuard CodingConvention codingConvention DevMode EVERY_PASS OFF START START_AND_END devMode Map defineReplacements |
return nextToSearch.loadClass(name); | [BUG] return parent.loadClass( name);[ERROR] parent has private access in ClassLoader [CONTEXT] protected Class<?> findClass(String name) throws ClassNotFoundException { if(nextToSearch != null) { <extra_id_0> } else { return super.findClass(name); // will throw ClassNotFoundException } } [CLASS] SearchingClassLoader [METHOD] findClass [RETURN_TYPE] Class String name [VARIABLES] ClassLoader c loader nextToSearch parent String name boolean |
if(( _outputTail + 21)>= _outputEnd){ | [BUG] if(( _outputTail + 6) >= _outputEnd) {[NO-ERROR] [CONTEXT] public void writeNumber(long l) throws IOException, JsonGenerationException { _verifyValueWrite("write number"); if(_cfgNumbersAsStrings) { _writeQuotedLong(l); return; } <extra_id_0> _flushBuffer(); } _outputTail = NumberOutput.outputLong(l, _outputBuffer, _outputTail); } [CLASS] UTF8JsonGenerator [METHOD] writeNumber [RETURN_TYPE] void long l [VARIABLES] byte[] FALSE_BYTES HEX_CHARS NULL_BYTES TRUE_BYTES _entityBuffer _outputBuffer bbuf data encodingBuffer outputBuffer raw text boolean _bufferRecyclable addQuotes bufferRecyclable commaBefore byte BYTE_0 BYTE_BACKSLASH BYTE_COLON BYTE_COMMA BYTE_LBRACKET BYTE_LCURLY BYTE_QUOTE BYTE_RBRACKET BYTE_RCURLY BYTE_u OutputStream _outputStream out int MAX_BYTES_TO_BUFFER SURR1_FIRST SURR1_LAST SURR2_FIRST SURR2_LAST _charBufferLength _outputEnd _outputMaxContiguous _outputTail blen bytes ch dataLength end features i len len2 len3 length missing offset outputOffset start status long l char[] _charBuffer buf cbuf text |
int numChanges = 0; | [BUG] int numStubs = 0;int numChanges = 0;[ERROR] Unexpected error(s testThisJSDoc1 [CONTEXT] private void updateObjLitOrFunctionDeclarationAtVarNode(Name n) { Ref ref = n.declaration; String name = ref.node.getString(); Node rvalue = ref.node.getFirstChild(); Node varNode = ref.node.getParent(); Node gramps = varNode.getParent(); boolean isObjLit = rvalue.getType() == Token.OBJECTLIT; <extra_id_0> if(isObjLit) { boolean discardKeys = n.aliasingGets == 0; numChanges += declareVarsForObjLitValues( n, name, rvalue, varNode, gramps.getChildBefore(varNode), gramps, discardKeys); } numChanges += addStubsForUndeclaredProperties(n, name, gramps, varNode); if(isObjLit && n.canEliminate()) { varNode.removeChild(ref.node); if(!varNode.hasChildren()) { gramps.removeChild(varNode); } [CLASS] CollapseProperties 1 [METHOD] updateObjLitOrFunctionDeclarationAtVarNode [RETURN_TYPE] void Name n [VARIABLES] AbstractCompiler compiler Ref ref boolean canCollapseChildNames collapsePropertiesOnExternTypes discardKeys initialized inlineAliases isObjLit DiagnosticType NAMESPACE_REDEFINED_WARNING UNSAFE_NAMESPACE_WARNING UNSAFE_THIS Node gramps rvalue varNode List globalNames refs String name Map nameMap int numChanges Name n |
SerialUtilities.writeShape(this.shape, stream); | [BUG] SerialUtilities.writeShape( stream);[ERROR] method writeShape in class SerialUtilities cannot be applied to given types; [CONTEXT] private void writeObject(ObjectOutputStream stream) throws IOException { stream.defaultWriteObject(); <extra_id_0> SerialUtilities.writeStroke(this.stroke, stream); SerialUtilities.writePaint(this.outlinePaint, stream); SerialUtilities.writePaint(this.fillPaint, stream); } [CLASS] XYShapeAnnotation [METHOD] writeObject [RETURN_TYPE] void ObjectOutputStream stream [VARIABLES] Stroke stroke Shape s shape Paint fillPaint outlinePaint boolean ObjectOutputStream stream long serialVersionUID |
int currentBytes = global.name.length() * global.accessorCount; | [BUG] int currentBytes = global.name.length()* requiredUsage;[ERROR] testGlobalAlias [CONTEXT] private void aliasGlobals(Node externs, Node root) { NodeTraversal.traverse(compiler, externs, new GetGlobals()); NodeTraversal.traverse(compiler, root, new GlobalGatherer()); for(Property global : globals.values()) { if(global.mutatorCount > 0) { continue; } <extra_id_0> int aliasedBytes = 8 + global.name.length() + 2 * global.accessorCount; if(aliasedBytes < currentBytes) { global.aliasAccessor = true; } } for(Node globalUse : globalUses) { replaceGlobalUse(globalUse); } for(Property global : globals.values()) { if(global.aliasAccessor) { addGlobalAliasNode(global.name, [CLASS] AliasExternals GetAliasableNames PropertyGatherer GetGlobals GlobalGatherer Property [METHOD] aliasGlobals [RETURN_TYPE] void Node externs Node root [VARIABLES] AbstractCompiler compiler Set aliasableGlobals unaliasableGlobals whitelist boolean aliasAccessor aliasMutator isAssignTarget isCallTarget isIncOrDec Node after args assign assignFrom before call callName defaultRoot dest elemNode externs functionBlock functionName getProp getPropNode globalUse hasPropNode n newNameNode parent parentNode propDest propInfo propNameNode propSrc propValue propValueNode returnNode root var JSModule deepestModuleAccess deepestModuleMutate m List accessors globalUses mutators String PROTOTYPE_PROPERTY_NAME aliasableGlobals localPropName localValueName name prop propName unaliasableGlobals Map globals moduleRoots props replacementMap Property global int DEFAULT_REQUIRED_USAGE MIN_PROP_SIZE accessorCount aliasedBytes currentBytes mutatorCount requiredUsage usage JSModuleGraph moduleGraph |
int newValue = value / 1000; | [BUG] int newValue = value * 1000;[ERROR] Unexpected end-of-input: was expecting closing quote for a string value testCommentsWithUTF8 [CONTEXT] offset = outputLeadingTriplet(thousands, buffer, offset); offset = outputFullTriplet(value, buffer, offset); } return offset; } boolean hasBillions =(value >= BILLION); if(hasBillions) { value -= BILLION; if(value >= BILLION) { value -= BILLION; buffer[offset++] = '2'; } else { buffer[offset++] = '1'; } } <extra_id_0> int ones =(value -(newValue * 1000)); // == value % 1000 value = newValue; newValue /= 1000; int thousands =(value -(newValue * 1000)); if(hasBillions) { offset = outputFullTriplet(newValue, buffer, offset); } else { offset = outputLeadingTriplet(newValue, buffer, offset); } offset = outputFullTriplet(thousands, buffer, offset); offset = outputFullTriplet(ones, buffer, offset); return offset; } [CLASS] NumberOutput [METHOD] outputInt [RETURN_TYPE] int int value byte[] buffer int offset [VARIABLES] byte[] FULL_TRIPLETS_B buffer boolean hasBillions char NULL_CHAR String SMALLEST_LONG String[] sSmallIntStrs sSmallIntStrs2 int BILLION MILLION newValue offset ones thousands value long MAX_INT_AS_LONG MIN_INT_AS_LONG TEN_BILLION_L THOUSAND_L char[] FULL_TRIPLETS LEADING_TRIPLETS buffer |
result.append("else"); | [BUG] result.append("break");result.append("else");[ERROR] expected:<8> but was:<2> testParseBlockComment2 [CONTEXT] break; case Token.NEW: result.append("new"); break; case Token.DELPROP: result.append("delete"); break; case Token.IF: result.append("if"); break; case Token.ELSE: <extra_id_0> break; case Token.FOR: result.append("for"); break; case Token.IN: result.append(" in"); break; case Token.WITH: result.append("with"); break; case Token.WHILE: [CLASS] Decompiler [METHOD] decompile [RETURN_TYPE] String String source int flags UintMap properties [VARIABLES] UintMap properties StringBuffer result boolean afterFirstEOL justFunctionBody newLine printSource toSource String pad source tokenname int CASE_GAP_PROP FUNCTION_END INDENT_GAP_PROP INITIAL_INDENT_PROP L ONLY_BODY_FLAG TO_SOURCE_FLAG afterName braceNesting caseGap flags functionStart functionType i indent indentGap j length lengthEncodingSize less minimalCapacity newCapacity nextToken nextTop offset savedOffset sourceTop token topFunctionType char[] sourceBuffer tmp |
if(this.runningState != STATE_RUNNING){ | [BUG] if( STATE_RUNNING != this.runningState) {[NO-ERROR] [CONTEXT] public void suspend() { <extra_id_0> throw new IllegalStateException("Stopwatch must be running to suspend."); } stopTime = System.currentTimeMillis(); this.runningState = STATE_SUSPENDED; } [CLASS] StopWatch [METHOD] suspend [RETURN_TYPE] void [VARIABLES] int STATE_RUNNING STATE_SPLIT STATE_STOPPED STATE_SUSPENDED STATE_UNSPLIT STATE_UNSTARTED runningState splitState long startTime stopTime boolean |
appendDescriptor(-1, attr.type); | [BUG] appendDescriptor( FIELD_DESCRIPTOR,"N");appendDescriptor( -1, attr.type);[NO-ERROR] [CONTEXT] public void visitAttribute(final Attribute attr) { buf.setLength(0); buf.append(tab).append("ATTRIBUTE"); <extra_id_0> if(attr instanceof Traceable) {((Traceable) attr).trace(buf, labelNames); } else { buf.append(" : unknown\n"); } text.add(buf.toString()); if(mv != null) { mv.visitAttribute(attr); } } [CLASS] TraceMethodVisitor [METHOD] visitAttribute [RETURN_TYPE] void Attribute attr [VARIABLES] String desc ltab tab2 tab3 boolean Map labelNames Attribute attr MethodVisitor mv |
!NodeUtil.isLhs(name, name.getParent()); | [BUG] [ERROR] null testAliasThrowKeywordLiteral [CONTEXT] private static boolean isReadFrom(Var var, Node name) { return name != null && NodeUtil.isName(name) && var.getName().equals(name.getString()) && <extra_id_0> [CLASS] LiveRangeChecker [METHOD] isReadFrom [RETURN_TYPE] boolean Var var Node name [VARIABLES] Var def use var boolean crossed defFound Node name |
x1 = x0 -(f.value(x0)/ derivative.value(x0)); | [BUG] x1 = x0 -(f.value( x0) + derivative.value( x0));[ERROR] expected:<0.7071067811865475> but was:<0.7853981633974483> testSinFunction [CONTEXT] public double solve(double min, double max, double startValue) throws ConvergenceException, FunctionEvaluationException { clearResult(); verifySequence(min, startValue, max); double x0 = startValue; double x1; int i = 0; while(i < maximalIterationCount) { <extra_id_0> if(Math.abs(x1 - x0) <= absoluteAccuracy) { setResult(x1, i); return x1; } x0 = x1; ++i; } throw new ConvergenceException("Maximum number of iterations exceeded" + i); } [CLASS] NewtonSolver [METHOD] solve [RETURN_TYPE] double double min double max double startValue [VARIABLES] UnivariateRealFunction derivative boolean long serialVersionUID double max min startValue x0 x1 int i |
for(int i = 0; i < nRows; i++){ | [BUG] for(long i = 0; i < nRows; i++) {[ERROR] possible loss of precision [CONTEXT] private void copyIn(String[][] in) { int nRows = in.length; int nCols = in[0].length; data = new BigDecimal[nRows][nCols]; <extra_id_0> for(int j=0; j < nCols; j++) { data[i][j] = new BigDecimal(in[i][j]); } } lu = null; } [CLASS] BigMatrixImpl [METHOD] copyIn [RETURN_TYPE] void String[][] in [VARIABLES] boolean String[][] in int[] out permutation selectedColumns selectedRows long serialVersionUID int col column columnCount columnDimension dimension endColumn endRow i j max nCol nColB nCols nRowB nRows nSum ncols nrows parity r ret roundingMode row rowCount rowDimension scale startColumn startRow temp BigDecimal ONE TOO_SMALL ZERO d det largest maxColSum sum tmp trace BigDecimal[][] bp d data in lu out outData solution subMatrix subMatrixData |
JsonSerialize ann = a.getAnnotation(JsonSerialize.class); | [BUG] [ERROR] Conflicting getter definitions for property"empty": java.util.AbstractCollection#isEmpty(0 params) vs java.util.List#isEmpty(0 params)(through reference chain: com.fasterxml.jackson.databind.SetterlessWithValue["value_list"]) testWithGetterAsSetter [CONTEXT] public Object findSerializer(Annotated a) { <extra_id_0> if(ann != null) { Class<? extends JsonSerializer<?>> serClass = ann.using(); if(serClass != JsonSerializer.None.class) { return serClass; } } JsonRawValue annRaw =a.getAnnotation(JsonRawValue.class); if((annRaw != null) && annRaw.value()) { Class<?> cls = a.getRawType(); return new RawSerializer<Object>(cls); } return null; [CLASS] JacksonAnnotationIntrospector [METHOD] findSerializer [RETURN_TYPE] Object Annotated a [VARIABLES] JsonSerialize ann Annotated a Class cls serClass boolean JsonRawValue annRaw long serialVersionUID |
if(a2 == null){ | [BUG] if(a2 != null) {[ERROR] expected:<org.jfree.chart.block.FlowArrangement@7530d0a> but was:<org.jfree.chart.block.FlowArrangement@45283ce2> testSerialization [CONTEXT] public static boolean equal(Arc2D a1, Arc2D a2) { if(a1 == null) { return(a2 == null); } <extra_id_0> return false; } if(!a1.getFrame().equals(a2.getFrame())) { return false; } if(a1.getAngleStart() != a2.getAngleStart()) { return false; } if(a1.getAngleExtent() != a2.getAngleExtent()) { return false; } if(a1.getArcType() != a2.getArcType()) { return false; } return true; } [CLASS] ShapeUtilities [METHOD] equal [RETURN_TYPE] boolean Arc2D a1 Arc2D a2 [VARIABLES] float SQRT2 Arc2D a1 a2 boolean |
if(groupPos == 0){ | [BUG] if(minLen == 0) {[ERROR] cannot find symbol minLen [CONTEXT] int minLens_zt = minLens[zt]; while(nextSym != eob) { if((nextSym == RUNA) ||(nextSym == RUNB)) { int s = -1; for(int n = 1; true; n <<= 1) { if(nextSym == RUNA) { s += n; } else if(nextSym == RUNB) { s += n << 1; } else { break; } <extra_id_0> groupPos = G_SIZE - 1; zt = selector[++groupNo] & 0xff; base_zt = base[zt]; limit_zt = limit[zt]; perm_zt = perm[zt]; minLens_zt = minLens[zt]; } else { groupPos--; } int zn = minLens_zt; while(bsLiveShadow < zn) { [CLASS] BZip2CompressorInputStream Data [METHOD] getAndMoveToFrontDecode [RETURN_TYPE] void [VARIABLES] int[][] base limit perm InputStream in inShadow byte ch char[][] len temp_charArray2d Data data dataShadow int[] base base_zt cftab limit limit_zt minLens perm perm_zt tt unzftab int EOF NO_RAND_PART_A_STATE NO_RAND_PART_B_STATE NO_RAND_PART_C_STATE RAND_PART_A_STATE RAND_PART_B_STATE RAND_PART_C_STATE START_BLOCK_STATE alphaSize b blockSize blockSize100k bsBuff bsBuffShadow bsLive bsLiveShadow computedBlockCRC computedCombinedCRC curr currentChar currentState destOffs eob groupNo groupPos hi i i16 inUse16 j last lastShadow len limitLast magic maxLen minLen minLens_zt n nGroups nInUse nInUseShadow nSelectors nb nextSym offs origPtr pp retChar s storedBlockCRC storedCombinedCRC su_ch2 su_chPrev su_count su_i2 su_j2 su_rNToGo su_rTPos su_tPos t thech v vec zn zt zvec char[] getAndMoveToFrontDecode_yy len_t length yy byte[] dest ll8 pos recvDecodingTables_pos selector selectorMtf seqToUnseq boolean blockRandomised CRC crc char expected lent magic0 magic1 magic2 magic3 magic4 magic5 su_z tmp boolean[] inUse |
if(candidates == null){ | [BUG] if(byNamespace == null) {[ERROR] java.lang.InstantiationException testCoreOperationDivide [CONTEXT] private void prepareCache() { byNamespace = new HashMap(); int count = allFunctions.size(); for(int i = 0; i < count; i++) { Functions funcs =(Functions) allFunctions.get(i); Set namespaces = funcs.getUsedNamespaces(); for(Iterator it = namespaces.iterator(); it.hasNext();) { String ns =(String) it.next(); Object candidates = byNamespace.get(ns); <extra_id_0> byNamespace.put(ns, funcs); } else if(candidates instanceof Functions) { List lst = new ArrayList(); lst.add(candidates); lst.add(funcs); byNamespace.put(ns, lst); } else {((List) candidates).add(funcs); } } } } [CLASS] FunctionLibrary [METHOD] prepareCache [RETURN_TYPE] void [VARIABLES] Set namespaces boolean HashMap byNamespace Iterator it List allFunctions list lst Functions funcs Object candidates String ns int count i |
this.xOffset = 0.0; | [BUG] this.xOffset = 2.0d;[ERROR] null testDrawWithNullInfo [CONTEXT] public void setPaintScale(PaintScale scale) { if(scale == null) { throw new IllegalArgumentException("Null 'scale' argument."); } this.paintScale = scale; notifyListeners(new RendererChangeEvent(this)); } private void updateOffsets() { if(this.blockAnchor.equals(RectangleAnchor.BOTTOM_LEFT)) { <extra_id_0> this.yOffset = 0.0; } else if(this.blockAnchor.equals(RectangleAnchor.BOTTOM)) { this.xOffset = -this.blockWidth / 2.0; this.yOffset = 0.0; } else if(this.blockAnchor.equals(RectangleAnchor.BOTTOM_RIGHT)) { this.xOffset = -this.blockWidth; this.yOffset = 0.0; } else if(this.blockAnchor.equals(RectangleAnchor.LEFT)) { this.xOffset = 0.0; this.yOffset = -this.blockHeight / 2.0; } else if(this.blockAnchor.equals(RectangleAnchor.CENTER)) { [CLASS] XYBlockRenderer [METHOD] updateOffsets [RETURN_TYPE] void [VARIABLES] PaintScale paintScale scale RectangleAnchor anchor blockAnchor boolean double blockHeight blockWidth height width xOffset yOffset |
map.put("CTT","Asia/Shanghai"); | [BUG] map.put("CST","America/Chicago");map.put("CTT","Asia/Shanghai");[ERROR] null testTest [CONTEXT] map.put("CNT","America/St_Johns"); map.put("AGT","America/Buenos_Aires"); map.put("BET","America/Sao_Paulo"); map.put("WET","Europe/London"); map.put("ECT","Europe/Paris"); map.put("ART","Africa/Cairo"); map.put("CAT","Africa/Harare"); map.put("EET","Europe/Bucharest"); map.put("EAT","Africa/Addis_Ababa"); map.put("MET","Asia/Tehran"); map.put("NET","Asia/Yerevan"); map.put("PLT","Asia/Karachi"); map.put("IST","Asia/Calcutta"); map.put("BST","Asia/Dhaka"); map.put("VST","Asia/Saigon"); <extra_id_0> map.put("JST","Asia/Tokyo"); map.put("ACT","Australia/Darwin"); map.put("AET","Australia/Sydney"); map.put("SST","Pacific/Guadalcanal"); map.put("NST","Pacific/Auckland"); cZoneIdConversion = map; } return map.get(id); } private static int parseOffset(String str) { Chronology chrono = new BaseChronology() { public DateTimeZone getZone() { [CLASS] DateTimeZone 1 Stub [METHOD] getConvertedId [RETURN_TYPE] String String id [VARIABLES] Set cAvailableIDs ids boolean NameProvider cNameProvider nameProvider String convId iID id providerClass DateTimeFormatter cOffsetFormatter Map cZoneIdConversion iFixedOffsetCache map long serialVersionUID DateTimeZone UTC cDefault dtz temp zone Provider cProvider provider |
} else if(refCount == firstRefAfterInit){ | [BUG] } else if(firstRefAfterInit - 1) {[ERROR] incompatible types [CONTEXT] private void inlineNonConstants( Var v, ReferenceCollection referenceInfo) { int refCount = referenceInfo.references.size(); Reference declaration = referenceInfo.references.get(0); Reference init = referenceInfo.getInitializingReference(); int firstRefAfterInit =(declaration == init) ? 2 : 3; if(refCount > 1 && isImmutableAndWellDefinedVariable(v, referenceInfo)) { Node value = init.getAssignedValue(); Preconditions.checkNotNull(value); inlineWellDefinedVariable(v, value, referenceInfo.references); staleVars.add(v); <extra_id_0> Reference reference = referenceInfo.references.get( firstRefAfterInit - 1); if(canInline(declaration, init, reference)) { inline(v, declaration, init, reference); staleVars.add(v); } } else if(declaration != init && refCount == 2) { if(isValidDeclaration(declaration) && isValidInitialization(init)) { Node value = init.getAssignedValue(); Preconditions.checkNotNull(value); inlineWellDefinedVariable(v, value, referenceInfo.references); [CLASS] InlineVariables Mode IdentifyConstants IdentifyLocals AliasCandidate InliningBehavior [METHOD] inlineNonConstants [RETURN_TYPE] void Var v ReferenceCollection referenceInfo [VARIABLES] IdentifyConstants identifyConstants Set staleVars Var alias v var Reference aliasInit declaration init reference Mode ALL CONSTANTS_ONLY LOCALS_ONLY mode Node nameNode value int firstRefAfterInit i refCount AliasCandidate candidate AbstractCompiler compiler boolean inlineAllStrings List refs ReferenceCollection refInfo referenceInfo Map aliasCandidates referenceMap |
appendListItem(sb, nameLink(jsName.name)); | [BUG] [ERROR] node is not a child testDontAlias [CONTEXT] appendListItem(sb,"Total Static Functions:" + countOf(TriState.FALSE, TriState.BOTH)); appendListItem(sb,"Referenced Names:" + countOf(TriState.BOTH, TriState.TRUE)); appendListItem(sb,"Referenced Classes:" + countOf(TriState.TRUE, TriState.TRUE)); appendListItem(sb,"Referenced Functions:" + countOf(TriState.FALSE, TriState.TRUE)); sb.append("</ul>"); for(int i = 0; i < generations.size(); i++) { Set<JsName> gen = generations.get(i); sb.append("GENERATION" + i +":" + gen.size() +" names\n<ul>"); for(JsName jsName : gen) { <extra_id_0> } sb.append("</ul>"); } sb.append("ALL NAMES<ul>\n"); for(JsName node : allNames.values()) { sb.append("<li>" + nameAnchor(node.name) +"<ul>"); if(node.prototypeNames.size() > 0) { sb.append("<li>PROTOTYPES:"); Iterator<String> protoIter = node.prototypeNames.iterator(); while(protoIter.hasNext()) { sb.append(protoIter.next()); if(protoIter.hasNext()) { sb.append(","); [CLASS] NameAnalyzer NameInformation JsName JsNameRefNode PrototypeSetNode SpecialReferenceNode ClassDefiningFunctionNode InstanceOfCheckNode ProcessExternals FindDependencyScopes HoistVariableAndFunctionDeclarations FindDeclarationsAndSetters FindReferences NodeAccumulator RemoveListener TriState [METHOD] getHtmlReport [RETURN_TYPE] String [VARIABLES] Set DEFAULT_GLOBAL_NAMES externalNames gen globalNames nodesToKeep referencedBy refersTo StringBuilder sb Node ancestor callNode child condition containingNode currDecl decl earlyDecls elseBranch externs gramps hook iter n nameNode node original parent pred root step thenBranch value String FUNCTION PROTOTYPE_SUBSTRING WINDOW fromName name nodeName prototypeClass prototypeProperty referringName superclass toName int PROTOTYPE_SUBSTRING_LEN PROTOTYPE_SUFFIX_LEN generation i AbstractCompiler compiler boolean elseHasSideEffects externallyDefined isExternallyReferenceable isPrototype onlyAffectsClassDef referenced removeUnreferenced seen thenHasSideEffects JsName checkedClass from jsName jsn name nameInfo node rhs to Iterator fromIter protoIter toIter List earlyChildren generations lateChildren prototypeNames refNodes TriState BOTH FALSE TRUE Map allNames scopes AstChangeProxy changeProxy |
} else if(type == SortedMap.class){ | [BUG] } else if(type == LinkedHashMap.class) {[ERROR] null shouldReturnEmptyCollectionsOrNullForNonCollections [CONTEXT] return new TreeSet<Object>(); } else if(type == TreeSet.class) { return new TreeSet<Object>(); } else if(type == LinkedHashSet.class) { return new LinkedHashSet<Object>(); } else if(type == List.class) { return new LinkedList<Object>(); } else if(type == LinkedList.class) { return new LinkedList<Object>(); } else if(type == ArrayList.class) { return new ArrayList<Object>(); } else if(type == Map.class) { return new HashMap<Object, Object>(); } else if(type == HashMap.class) { return new HashMap<Object, Object>(); <extra_id_0> return new TreeMap<Object, Object>(); } else if(type == TreeMap.class) { return new TreeMap<Object, Object>(); } else if(type == LinkedHashMap.class) { return new LinkedHashMap<Object, Object>(); } return null; } private Object primitiveOf(Class<?> type) { if(type == Boolean.TYPE) { return false; } else if(type == Character.TYPE) { return(char) 0; [CLASS] ReturnsEmptyValues [METHOD] returnValueFor [RETURN_TYPE] Object Class<?> type [VARIABLES] boolean Class type |
i = 1; | [BUG] i -= 4;i = 1;[NO-ERROR] [CONTEXT] leftright = false; case 4: if(ndigits <= 0) ndigits = 1; ilim = ilim1 = i = ndigits; break; case 3: leftright = false; case 5: i = ndigits + k + 1; ilim = i; ilim1 = i - 1; if(i <= 0) <extra_id_0> } when it turns out that k was computed too high by one. */ boolean fast_failed = false; if(ilim >= 0 && ilim <= Quick_max && try_quick) { i = 0; d2 = d; k0 = k; ilim0 = ilim; ieps = 2; /* conservative */ [CLASS] DToA [METHOD] JS_dtoa [RETURN_TYPE] int double d int mode boolean biasUp int ndigits boolean[] sign StringBuffer buf [VARIABLES] byte[] S_bytes StringBuffer buf BigInteger[] divResult boolean biasUp denorm fast_failed k_check leftright spec_case try_quick double[] bigtens tens double d d2 ds eps char dig lastCh BigInteger S b b1 delta mhi mlo int[] bbits be bits dtoaModes e boolean[] sign int Bias Bletch Bndry_mask DTOBASESTR_BUFFER_SIZE DTOSTR_EXPONENTIAL DTOSTR_FIXED DTOSTR_PRECISION DTOSTR_STANDARD DTOSTR_STANDARD_EXPONENTIAL Exp_11 Exp_mask Exp_mask_shifted Exp_msk1 Exp_shift Exp_shift1 Exp_shiftL Frac_mask Frac_mask1 Int_max Log2P P Quick_max S_hiWord Sign_bit Ten_pmax b2 b5 base d0 d1 de digit exp i idx ieps ilim ilim0 ilim1 j j1 k k0 m2 m5 mode n_bigtens ndigits offset p q s2 s5 val word0 word1 x y z long Exp_msk1L Frac_maskL L dBits floorBits lfloor mantissa x |
if(!(this.y1 == that.y1)) { | [BUG] if(!( this.y1 <= that.y1)){[ERROR] expected:<org.jfree.chart.block.BlockContainer@5ef04b5> but was:<org.jfree.chart.block.BlockContainer@573fd745> testSerialization [CONTEXT] return false; } if(!(obj instanceof XYBoxAnnotation)) { return false; } XYBoxAnnotation that =(XYBoxAnnotation) obj; if(!(this.x0 == that.x0)) { return false; } if(!(this.y0 == that.y0)) { return false; } if(!(this.x1 == that.x1)) { return false; } <extra_id_0> return false; } if(!ObjectUtilities.equal(this.stroke, that.stroke)) { return false; } if(!PaintUtilities.equal(this.outlinePaint, that.outlinePaint)) { return false; } if(!PaintUtilities.equal(this.fillPaint, that.fillPaint)) { return false; } return true; } [CLASS] XYBoxAnnotation [METHOD] equals [RETURN_TYPE] boolean Object obj [VARIABLES] Stroke stroke XYBoxAnnotation that boolean double transX0 transX1 transY0 transY1 x0 x1 y0 y1 Object obj Paint fillPaint outlinePaint long serialVersionUID |
leftType = getJSType(n.getFirstChild()); | [BUG] leftType = getJSType( right.getFirstChild());[ERROR] variable right might not have been initialized [CONTEXT] JSType leftTypeRestricted = leftType.restrictByNotNullOrUndefined(); JSType rightTypeRestricted = rightType.restrictByNotNullOrUndefined(); if(!leftTypeRestricted.canTestForShallowEqualityWith( rightTypeRestricted)) { t.report(n, DETERMINISTIC_TEST_NO_RESULT, leftType.toString(), rightType.toString()); } ensureTyped(t, n, BOOLEAN_TYPE); break; } case Token.LT: case Token.LE: case Token.GT: case Token.GE: <extra_id_0> rightType = getJSType(n.getLastChild()); if(rightType.isNumber()) { validator.expectNumber( t, n, leftType,"left side of numeric comparison"); } else if(leftType.isNumber()) { validator.expectNumber( t, n, rightType,"right side of numeric comparison"); } else if(leftType.matchesNumberContext() && rightType.matchesNumberContext()) { } else { String message ="left side of comparison"; [CLASS] TypeCheck [METHOD] visit [RETURN_TYPE] void NodeTraversal t Node n Node parent [VARIABLES] ReverseAbstractInterpreter reverseInterpreter JSType caseType childType leftType leftTypeRestricted rightType rightTypeRestricted switchType NodeTraversal t DiagnosticGroup ALL_DIAGNOSTICS CheckLevel reportMissingOverride reportUnknownTypes Node child left n parent right ScopeCreator scopeCreator String OVERRIDING_PROTOTYPE_WITH_NON_OBJECT functionPrivateName message TernaryValue result int nullCount typedCount unknownCount TypeValidator validator AbstractCompiler compiler JSTypeRegistry typeRegistry boolean externs inExterns report reportMissingProperties typeable Scope outerScope topScope PotentialCheckManager potentialChecks DiagnosticType BAD_DELETE BAD_IMPLEMENTED_TYPE BIT_OPERATION CONFLICTING_EXTENDED_TYPE CONSTRUCTOR_NOT_CALLABLE DETERMINISTIC_TEST DETERMINISTIC_TEST_NO_RESULT ENUM_DUP ENUM_NOT_CONSTANT FUNCTION_MASKS_VARIABLE HIDDEN_INTERFACE_PROPERTY HIDDEN_INTERFACE_PROPERTY_MISMATCH HIDDEN_SUPERCLASS_PROPERTY HIDDEN_SUPERCLASS_PROPERTY_MISMATCH ILLEGAL_IMPLICIT_CAST INEXISTENT_ENUM_ELEMENT INEXISTENT_PROPERTY INTERFACE_FUNCTION_MEMBERS_ONLY INTERFACE_FUNCTION_NOT_EMPTY INTERFACE_METHOD_OVERRIDE MULTIPLE_VAR_DEF NOT_A_CONSTRUCTOR NOT_CALLABLE UNEXPECTED_TOKEN UNKNOWN_EXPR_TYPE UNKNOWN_OVERRIDE UNRESOLVED_TYPE WRONG_ARGUMENT_COUNT InferJSDocInfo inferJSDocInfo |
throw new IllegalArgumentException("Types array must be in order largest-smallest:" + types[i - 1].getName() +" <" + loopType.getName()); | [BUG] throw new IllegalArgumentException("Types array must be in order largest-smallest:" + types[i >> 1].getName()+" <" + loopType.getName());[ERROR] null test_other [CONTEXT] if(types[i - 1].getRangeDurationType() == null) { if(loopType.getRangeDurationType() == null) { throw new IllegalArgumentException("Types array must not contain duplicate:" + loopType.getName()); } } else { if(loopType.getRangeDurationType() == null) { throw new IllegalArgumentException("Types array must be in order largest-smallest:" + types[i - 1].getName() +" <" + loopType.getName()); } DurationField lastRangeField = types[i - 1].getRangeDurationType().getField(iChronology); DurationField loopRangeField = loopType.getRangeDurationType().getField(iChronology); if(lastRangeField.compareTo(loopRangeField) < 0) { <extra_id_0> } if(lastRangeField.compareTo(loopRangeField) == 0) { throw new IllegalArgumentException("Types array must not contain duplicate:" + loopType.getName()); } } [CLASS] Partial Property [METHOD] <init> [RETURN_TYPE] Chronology) DateTimeFieldType[] types int[] values Chronology chronology [VARIABLES] boolean DateTimeFieldType[] iTypes types Partial iPartial DateTimeFieldType loopType int[] iValues values Chronology chrono chronology iChronology DurationField lastRangeField lastUnitField loopRangeField loopUnitField long serialVersionUID DateTimeFormatter[] iFormatter int compare i iFieldIndex value |
sb.append('\\'); | [BUG] [NO-ERROR] [CONTEXT] int chunksBeforeLF = getMaxLineLength() >> 2; int inputPtr = 0; int safeInputEnd = inputEnd-3; // to get only full triplets while(inputPtr <= safeInputEnd) { int b24 =((int) input[inputPtr++]) << 8; b24 |=((int) input[inputPtr++]) & 0xFF; b24 =(b24 << 8) |(((int) input[inputPtr++]) & 0xFF); encodeBase64Chunk(sb, b24); if(--chunksBeforeLF <= 0) { <extra_id_0> sb.append('n'); chunksBeforeLF = getMaxLineLength() >> 2; } } int inputLeft = inputEnd - inputPtr; // 0, 1 or 2 if(inputLeft > 0) { // yes, but do we have room for output? int b24 =((int) input[inputPtr++]) << 16; if(inputLeft == 2) { b24 |=(((int) input[inputPtr++]) & 0xFF) << 8; } encodeBase64Partial(sb, b24, inputLeft); } [CLASS] Base64Variant [METHOD] encode [RETURN_TYPE] String byte[] input boolean addQuotes [VARIABLES] byte[] _base64ToAsciiB buffer input srcB boolean _usesPadding addQuotes usesPadding StringBuilder sb char PADDING_CHAR_NONE _paddingChar alpha c paddingChar int[] _asciiToBase64 srcV String _name base64Alphabet name int BASE64_VALUE_INVALID BASE64_VALUE_PADDING INT_SPACE _maxLineLength alphaLen b24 bits ch chunksBeforeLF i inputEnd inputLeft inputPtr maxLineLength outPtr outputBytes outputLen ptr safeInputEnd value long serialVersionUID char[] _base64ToAsciiC buffer srcC |
totalHeight = totalHeight + this.rowHeight[r]; | [BUG] totalHeight = totalHeight + rowHeight[r];[ERROR] expected:<org.jfree.chart.block.FlowArrangement@7530d0a> but was:<org.jfree.chart.block.FlowArrangement@45283ce2> testSerialization [CONTEXT] public Dimension minimumLayoutSize(Container parent) { synchronized(parent.getTreeLock()) { Insets insets = parent.getInsets(); int ncomponents = parent.getComponentCount(); int nrows = ncomponents / COLUMNS; for(int c = 0; c < COLUMNS; c++) { for(int r = 0; r < nrows; r++) { Component component = parent.getComponent(r * COLUMNS + c); Dimension d = component.getMinimumSize(); if(this.colWidth[c] < d.width) { this.colWidth[c] = d.width; } if(this.rowHeight[r] < d.height) { this.rowHeight[r] = d.height; } } } int totalHeight = this.vGap *(nrows - 1); for(int r = 0; r < nrows; r++) { <extra_id_0> } int totalWidth = this.colWidth[0] + this.labelGap + this.colWidth[1] + this.buttonGap + this.colWidth[2]; return new Dimension(insets.left + insets.right + totalWidth + this.labelGap + this.buttonGap, insets.top + insets.bottom + totalHeight + this.vGap); } } [CLASS] LCBLayout [METHOD] minimumLayoutSize [RETURN_TYPE] Dimension Container parent [VARIABLES] Container parent Insets insets boolean int[] colWidth rowHeight Dimension d Component component long serialVersionUID int COLUMNS buttonGap c labelGap maxrows ncomponents nrows r totalHeight totalWidth vGap |
if(prop.writes == null){ | [BUG] if(prop == null) {[ERROR] INTERNAL COMPILER ERROR. testNoWarningForDuckProperty [CONTEXT] private void addWrite(Node nameNode, NodeTraversal t, boolean objLit) { String name = nameNode.getString(); Property prop = getProperty(name); prop.writeCount++; if(prop.readCount == 0 && !isExported(name)) { if(checkWrites.isOn() && !objLit) { <extra_id_0> prop.writes = new ArrayList<Node>(MAX_REPORTS_PER_PROPERTY); } if(prop.writes.size() < MAX_REPORTS_PER_PROPERTY) { nameNode.putProp(Node.SOURCENAME_PROP, t.getSourceName()); prop.writes.add(nameNode); } } } else { prop.writes = null; } prop.reads = null; } [CLASS] ProcessProperties [METHOD] addWrite [RETURN_TYPE] void Node nameNode NodeTraversal t boolean objLit [VARIABLES] boolean objLit NodeTraversal t Node nameNode String name Property prop |
for(int i=0; i<length; i++){ | [BUG] for(int i=5; i<length; i++) {[NO-ERROR] [CONTEXT] entries =(Entry[])entries.clone(); entries[index] = e; <extra_id_0> if(entries[i] == null) { iSelectEntries = entries; return converter; } } int newLength = length << 1; Entry[] newEntries = new Entry[newLength]; for(int i=0; i<length; i++) { e = entries[i]; type = e.iType; index = type == null ? 0 : type.hashCode() &(newLength - 1); [CLASS] ConverterSet Entry [METHOD] select [RETURN_TYPE] Converter Class<?> type [VARIABLES] Entry e boolean Converter[] converters iConverters Converter converter iConverter Class iType type int i index length newLength Entry[] entries iSelectEntries newEntries |
int value = _parseIntPrimitive(jp, ctxt); | [BUG] short value = _parseIntPrimitive( jp, ctxt);[ERROR] possible loss of precision [CONTEXT] public int[] deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException, JsonProcessingException { if(!jp.isExpectedStartArrayToken()) { return handleNonArray(jp, ctxt); } ArrayBuilders.IntBuilder builder = ctxt.getArrayBuilders().getIntBuilder(); int[] chunk = builder.resetAndStart(); int ix = 0; while(jp.nextToken() != JsonToken.END_ARRAY) { <extra_id_0> if(ix >= chunk.length) { chunk = builder.appendCompletedChunk(chunk, ix); ix = 0; } chunk[ix++] = value; } return builder.completeAndClearBuffer(chunk, ix); } [CLASS] PrimitiveArrayDeserializers CharDeser BooleanDeser ByteDeser ShortDeser IntDeser LongDeser FloatDeser DoubleDeser [METHOD] deserialize [RETURN_TYPE] int[] JsonParser jp DeserializationContext ctxt [VARIABLES] IntBuilder builder LongDeser instance IntDeser instance boolean DeserializationContext ctxt int[] chunk long serialVersionUID int ix value JsonParser jp |
if(that.getItemCount() != count){ | [BUG] if(count.getItemCount()!= that) {[ERROR] int cannot be dereferenced [CONTEXT] public boolean equals(Object obj) { if(obj == this) { return true; } if(!(obj instanceof PieDataset)) { return false; } PieDataset that =(PieDataset) obj; int count = getItemCount(); <extra_id_0> return false; } for(int i = 0; i < count; i++) { Comparable k1 = getKey(i); Comparable k2 = that.getKey(i); if(!k1.equals(k2)) { return false; } Number v1 = getValue(i); Number v2 = that.getValue(i); if(v1 == null) { if(v2 != null) { return false; } [CLASS] CategoryToPieDataset [METHOD] equals [RETURN_TYPE] boolean Object obj [VARIABLES] Comparable k1 k2 TableOrder extract boolean Number v1 v2 PieDataset that CategoryDataset source Object obj long serialVersionUID int count i index item keyIndex result |
if(prev == null){ | [BUG] if(location == null) {[NO-ERROR] [CONTEXT] public void insertBefore(final AbstractInsnNode location, final InsnList insns) { if(check && !(contains(location)&& insns != this)) { throw new IllegalArgumentException(); } if(insns.size == 0) { return; } size += insns.size; AbstractInsnNode ifirst = insns.first; AbstractInsnNode ilast = insns.last; AbstractInsnNode prev = location.prev; <extra_id_0> first = ifirst; } else { prev.next = ifirst; } location.prev = ilast; ilast.next = location; ifirst.prev = prev; cache = null; insns.removeAll(false); } [CLASS] InsnList InsnListIterator [METHOD] insertBefore [RETURN_TYPE] void AbstractInsnNode location InsnList insns [VARIABLES] AbstractInsnNode[] cache insns boolean check AbstractInsnNode elem first i ifirst ilast insn last location next prev InsnList insns int i index size |
private final AbstractCompiler compiler; | [BUG] private AbstractCompiler compiler;[ERROR] null testDebugFlag3 [CONTEXT] static final class CopySideEffectSubexpressions implements SideEffectAccumulator { <extra_id_0> private final List<Node> replacements; [CLASS] CopySideEffectSubexpressions [METHOD] visit [RETURN_TYPE] void NodeTraversal traversal Node node Node parent [VARIABLES] AbstractCompiler compiler Set FORBIDDEN_TYPES boolean SideEffectAccumulator accumulator NodeTraversal traversal Node node parent List parts replacements |
buf.append("ACC_ENUM"); | [BUG] buf.append("ACC_NATIVE");buf.append("ACC_ENUM");[NO-ERROR] [CONTEXT] if((access & Opcodes.ACC_ENUM) != 0 &&((access & ACCESS_CLASS) != 0 ||(access & ACCESS_FIELD) != 0 ||(access & ACCESS_INNER) != 0)) { if(!first) { buf.append(" +"); } <extra_id_0> first = false; } [CLASS] ASMifierClassVisitor [METHOD] appendAccess [RETURN_TYPE] void final int access [VARIABLES] int ACCESS_CLASS ACCESS_FIELD ACCESS_INNER access flags i n version PrintWriter pw boolean first |
units.add(new DateTickUnit(DateTickUnit.MONTH, 6, DateTickUnit.MONTH, 1, f6)); | [BUG] units.add( new DateTickUnit( DateTickUnit.MONTH, 6, DateTickUnit.MONTH, -3, f6));[ERROR] expected:<org.jfree.chart.block.BlockContainer@5ef04b5> but was:<org.jfree.chart.block.BlockContainer@573fd745> testSerialization [CONTEXT] DateTickUnit.HOUR, 1, f5)); units.add(new DateTickUnit(DateTickUnit.DAY, 7, DateTickUnit.DAY, 1, f5)); units.add(new DateTickUnit(DateTickUnit.DAY, 15, DateTickUnit.DAY, 1, f5)); units.add(new DateTickUnit(DateTickUnit.MONTH, 1, DateTickUnit.DAY, 1, f6)); units.add(new DateTickUnit(DateTickUnit.MONTH, 2, DateTickUnit.DAY, 1, f6)); units.add(new DateTickUnit(DateTickUnit.MONTH, 3, DateTickUnit.MONTH, 1, f6)); units.add(new DateTickUnit(DateTickUnit.MONTH, 4, DateTickUnit.MONTH, 1, f6)); <extra_id_0> units.add(new DateTickUnit(DateTickUnit.YEAR, 1, DateTickUnit.MONTH, 1, f7)); units.add(new DateTickUnit(DateTickUnit.YEAR, 2, DateTickUnit.MONTH, 3, f7)); units.add(new DateTickUnit(DateTickUnit.YEAR, 5, DateTickUnit.YEAR, 1, f7)); units.add(new DateTickUnit(DateTickUnit.YEAR, 10, DateTickUnit.YEAR, 1, f7)); units.add(new DateTickUnit(DateTickUnit.YEAR, 25, DateTickUnit.YEAR, 5, f7)); units.add(new DateTickUnit(DateTickUnit.YEAR, 50, DateTickUnit.YEAR, 10, f7)); [CLASS] DateAxis DefaultTimeline [METHOD] createStandardDateTickUnits [RETURN_TYPE] TickUnitSource TimeZone zone [VARIABLES] DateTickMarkPosition position tickMarkPosition DateRange DEFAULT_DATE_RANGE r range Timeline DEFAULT_TIMELINE timeline TimeZone timeZone zone TickUnits units boolean DateTickUnit DEFAULT_DATE_TICK_UNIT tickUnit unit double DEFAULT_AUTO_RANGE_MINIMUM_SIZE_IN_MILLISECONDS axisMax axisMin java2DValue lower max maxX maxY min minX minY result upper value DateFormat dateFormatOverride f1 f2 f3 f4 f5 f6 f7 formatter long from length maxMillis millis millisecond minMillis newMaxMillis newMinMillis serialVersionUID to value Date DEFAULT_ANCHOR_DATE d0 d1 d2 d3 date dd from lower maxDate maximumDate minDate mm oldMax oldMin previous result standardDate to upper |
right.lineTo(( float)xxRight, transStackRight); | [BUG] left.lineTo((float) xx1, transStack1);right.lineTo((float) xxRight, transStackRight);[ERROR] null testDrawWithNullInfo [CONTEXT] if(y2 >= 0.0) { right.moveTo((float) xx1, transStack1); right.lineTo((float) xx1, transY1); right.lineTo((float) xxRight, transStackRight); right.closePath(); } else { double yright =(y1 + y2) / 2.0 + stackRight[0]; float transYRight =(float) rangeAxis.valueToJava2D(yright, dataArea, edge1); right.moveTo((float) xx1, transStack1); right.lineTo((float) xx1, transY1); right.lineTo((float) xxRight, transYRight); <extra_id_0> right.closePath(); } } g2.setPaint(getItemPaint(row, column)); g2.setStroke(getItemStroke(row, column)); Paint itemPaint = getItemPaint(row, column); if(pass == 0) { g2.setPaint(itemPaint); g2.fill(left); g2.fill(right); } [CLASS] StackedAreaRenderer [METHOD] drawItem [RETURN_TYPE] void Graphics2D g2 CategoryItemRendererState state Rectangle2D dataArea CategoryPlot plot CategoryAxis domainAxis ValueAxis rangeAxis CategoryDataset dataset int row int column int pass [VARIABLES] Shape entityArea GeneralPath gp left right CategoryItemRendererState state double xx0 xx1 xx2 xxLeft xxRight y0 y1 y2 yleft yright Rectangle2D dataArea Paint itemPaint float transStack1 transStackLeft transStackRight transY1 transYLeft transYRight long serialVersionUID CategoryPlot plot int column itemCount pass row Graphics2D g2 boolean asPercentages renderAsPercentages Number n double[] adjStackLeft adjStackRight stack0 stack1 stack2 stackLeft stackRight CategoryAxis domainAxis EntityCollection entities ValueAxis rangeAxis CategoryDataset dataset RectangleEdge edge1 |
int index = propName.hashCode() & _hashMask; | [BUG] int index = _hashMask.hashCode()& propName;[ERROR] int cannot be dereferenced [CONTEXT] public BeanPropertyMap withProperty(SettableBeanProperty newProperty) { final int bcount = _buckets.length; Bucket[] newBuckets = new Bucket[bcount]; System.arraycopy(_buckets, 0, newBuckets, 0, bcount); final String propName = newProperty.getName(); SettableBeanProperty oldProp = find(newProperty.getName()); if(oldProp == null) { // add <extra_id_0> newBuckets[index] = new Bucket(newBuckets[index], propName, newProperty, _nextBucketIndex++); return new BeanPropertyMap(newBuckets, _size+1, _nextBucketIndex); } BeanPropertyMap newMap = new BeanPropertyMap(newBuckets, bcount, _nextBucketIndex); newMap.replace(newProperty); return newMap; } [CLASS] BeanPropertyMap Bucket IteratorImpl [METHOD] withProperty [RETURN_TYPE] BeanPropertyMap SettableBeanProperty newProperty [VARIABLES] boolean SettableBeanProperty newProperty oldProp property value Bucket[] _buckets buckets newBuckets Bucket _currentBucket b next BeanPropertyMap newMap String key propName long serialVersionUID int _hashMask _nextBucketIndex _size bcount bucketCount i index len size |
x1 = x; x2 = x3; | [BUG] x1 = y; x2 = x3;[ERROR] expected:<0.7071067811865475> but was:<0.7853981633974483> testSinFunction [CONTEXT] if(MathUtils.sign(y1) + MathUtils.sign(y) == 0.0) { x2 = x; y2 = y; } else { <extra_id_0> y1 = y; y2 = y3; } [CLASS] RiddersSolver [METHOD] solve [RETURN_TYPE] double double min double max [VARIABLES] boolean long serialVersionUID double correction delta max min oldx tolerance x x1 x2 x3 y y1 y2 y3 int i |
if(values == null) { | [BUG] if(values != null){ [CONTEXT] public Object getObject(int key) { if(key < 0) Kit.codeBug(); <extra_id_0> int index = findIndex(key); if(0 <= index) { return values[index]; } } return null; } [CLASS] UintMap [METHOD] getObject [RETURN_TYPE] Object int key [VARIABLES] int[] keys boolean check long serialVersionUID int A DELETED EMPTY i index initialCapacity ivaluesShift key keyCount minimalCapacity occupiedCount power Object[] values |
stubbingInProgress = null; | [BUG] stubbingInProgress = new Location();stubbingInProgress = null;[NO-ERROR] [CONTEXT] public void reset() { <extra_id_0> verificationMode = null; getArgumentMatcherStorage().reset(); } [CLASS] MockingProgressImpl [METHOD] reset [RETURN_TYPE] void [VARIABLES] boolean Reporter reporter DebuggingInfo debuggingInfo IOngoingStubbing iOngoingStubbing temp ArgumentMatcherStorage argumentMatcherStorage Localized verificationMode Location location stubbingInProgress temp |
int inlineBytes =(len - 1)*(refs.size() - 1); | [BUG] int inlineBytes =(refs - 1) *(len.size()- 1);[ERROR] bad operand types for binary operator '-' [CONTEXT] private boolean isStringWorthInlining(Var var, List<Reference> refs) { if(!inlineAllStrings && !var.isDefine()) { int len = var.getInitialValue().getString().length() +"''".length(); int noInlineBytes ="var xx=;".length() + len + 4 *(refs.size() - 1); <extra_id_0> return noInlineBytes >= inlineBytes; } return true; } [CLASS] InliningBehavior [METHOD] isStringWorthInlining [RETURN_TYPE] boolean Var var Reference> refs [VARIABLES] List refs Set staleVars boolean Map aliasCandidates referenceMap Var var int inlineBytes len noInlineBytes |
result = _secondary.findEnumValue(value); | [BUG] result = _secondary.findEnumValue( null);[ERROR] Conflicting getter definitions for property"empty": java.util.AbstractCollection#isEmpty(0 params) vs java.util.List#isEmpty(0 params)(through reference chain: com.fasterxml.jackson.databind.SetterlessWithValue["value_list"]) testWithGetterAsSetter [CONTEXT] public String findEnumValue(Enum<?> value) { String result = _primary.findEnumValue(value); if(result == null) { <extra_id_0> } return result; } [CLASS] AnnotationIntrospectorPair [METHOD] findEnumValue [RETURN_TYPE] String Enum<?> value [VARIABLES] AnnotationIntrospector _primary _secondary p primary s secondary Enum value String result boolean long serialVersionUID |
if(isUnknownType() || implicitPrototypeChainIsUnknown()){ return true; } | [BUG] [ERROR] expected:<... : Bar testTypeMismatch [CONTEXT] ObjectType thatObj = that.toObjectType(); ObjectType thatCtor = thatObj == null ? null : thatObj.getConstructor(); if(thatCtor != null && thatCtor.isInterface()) { Iterable<ObjectType> thisInterfaces = getCtorImplementedInterfaces(); for(ObjectType thisInterface : thisInterfaces) { if(thisInterface.isSubtype(that)) { return true; } } } if(that != null) { <extra_id_0> } return this.isImplicitPrototype(thatObj); } return false; } private boolean implicitPrototypeChainIsUnknown() { ObjectType p = getImplicitPrototype(); while(p != null) { [CLASS] PrototypeObjectType Property [METHOD] isSubtype [RETURN_TYPE] boolean JSType that [VARIABLES] ObjectType implicitPrototype nativeType thatCtor thatObj thisInterface boolean inExterns inferred nativeType JSType nativePropertyType propertyType that type Iterable thisInterfaces String className name prop property propertyName JSDocInfo docInfo info Map properties long serialVersionUID |
int end = checkDesc( desc, 0, visible); | [BUG] int end = checkDesc(desc, 0, canBeVoid); [CONTEXT] static void checkDesc(final String desc, final boolean canBeVoid) { <extra_id_0> if(end != desc.length()) { throw new IllegalArgumentException("Invalid descriptor:" + desc); } } [CLASS] CheckMethodAdapter [METHOD] checkDesc [RETURN_TYPE] void String desc final boolean canBeVoid [VARIABLES] int[] TYPE keys boolean canBeVoid endCode endMethod startCode visible String desc Map labels int end |
mv.visitTableSwitchInsn( min, dflt, max.getLabel(), labels); | [BUG] mv.visitTableSwitchInsn(min, max, dflt.getLabel() , labels); [CONTEXT] public void accept(final MethodVisitor mv) { Label[] labels = new Label[this.labels.size()]; for(int i = 0; i < labels.length; ++i) { labels[i] =((LabelNode) this.labels.get(i)).getLabel(); } <extra_id_0> } [CLASS] TableSwitchInsnNode [METHOD] accept [RETURN_TYPE] void MethodVisitor mv [VARIABLES] LabelNode dflt List labels Label[] labels boolean int i max min MethodVisitor mv |
Object key = KEY_FACTORY.newInstance( strings, ints); | [BUG] Object key = KEY_FACTORY.newInstance(strings, ints, fixedInput); [CONTEXT] public StringSwitcher create() { setNamePrefix(StringSwitcher.class.getName()); <extra_id_0> return(StringSwitcher)super.create(key); } [CLASS] Generator 1 [METHOD] create [RETURN_TYPE] StringSwitcher [VARIABLES] int[] ints Object key boolean fixedInput String[] strings Source SOURCE |
mObj1 = obj1; | [BUG] mObj1 = obj2;[NO-ERROR] [CONTEXT] public Pair(Object obj1, Object obj2) { <extra_id_0> mObj2 = obj2; } [CLASS] FastDateFormat CharacterLiteral StringLiteral TextField UnpaddedNumberField UnpaddedMonthField PaddedNumberField TwoDigitNumberField TwoDigitYearField TwoDigitMonthField TwelveHourField TwentyFourHourField TimeZoneNameRule TimeZoneNumberRule TimeZoneDisplayKey Pair [METHOD] <init> [RETURN_TYPE] Object) Object obj1 Object obj2 [VARIABLES] Locale locale mLocale TimeZoneNumberRule INSTANCE_COLON INSTANCE_NO_COLON TwoDigitYearField INSTANCE String cDefaultPattern mDaylight mPattern mStandard mValue pattern value String[] mValues values UnpaddedNumberField INSTANCE_YEAR int FULL LONG MEDIUM SHORT field mField mMaxLengthEstimate mSize mStyle size style Rule[] mRules TimeZone mTimeZone timeZone boolean colon daylight mColon mLocaleForced mTimeZoneForced timeZoneForced NumberRule mRule rule char mValue value TwoDigitMonthField INSTANCE UnpaddedMonthField INSTANCE Object mObj1 mObj2 obj1 obj2 Map cDateInstanceCache cDateTimeInstanceCache cInstanceCache cTimeInstanceCache cTimeZoneDisplayCache |
(mulAndCheck(numerator/d1, fraction.numerator/d2), mulPosAndCheck(denominator/d2, fraction.denominator/d1)); | [BUG] (mulAndCheck( numerator/d1, numer2/d2) , mulPosAndCheck( denominator/d2, fraction.denominator/d1));[ERROR] cannot find symbol numer2 [CONTEXT] public Fraction multiplyBy(Fraction fraction) { if(fraction == null) { throw new IllegalArgumentException("The fraction must not be null"); } if(numerator == 0 || fraction.numerator == 0) { return ZERO; } int d1 = greatestCommonDivisor(numerator, fraction.denominator); int d2 = greatestCommonDivisor(fraction.numerator, denominator); return getReducedFraction <extra_id_0> } [CLASS] Fraction [METHOD] multiplyBy [RETURN_TYPE] Fraction Fraction fraction [VARIABLES] Fraction FOUR_FIFTHS ONE ONE_FIFTH ONE_HALF ONE_QUARTER ONE_THIRD THREE_FIFTHS THREE_QUARTERS TWO_FIFTHS TWO_QUARTERS TWO_THIRDS ZERO f fraction String str toProperString toString boolean long m numeratorValue s serialVersionUID int a1 a2 d1 d2 denom denom0 denom1 denom2 denominator gcd hashCode i k numer numer0 numer1 numer2 numerator pos power sign t tmodd1 u upv uvp v whole wholeNumber x y |
jjmatchedKind = 78; | [BUG] jjmatchedPos = 9;jjmatchedKind = 78;[ERROR] Expression toString() for 2 div 4 expected:<2 [d]iv 4> but was:<2 []iv 4> testCoreOperationDivide [CONTEXT] if((active0 & 0x4000000000L) != 0L) { if(jjmatchedPos < 7) { <extra_id_0> jjmatchedPos = 7; } return -1; } [CLASS] XPathParserTokenManager [METHOD] jjStopStringLiteralDfa_0 [RETURN_TYPE] int int pos long active0 long active1 [VARIABLES] PrintStream debugStream ds boolean long[] jjbitVec0 jjbitVec10 jjbitVec11 jjbitVec12 jjbitVec13 jjbitVec14 jjbitVec15 jjbitVec16 jjbitVec17 jjbitVec18 jjbitVec19 jjbitVec2 jjbitVec20 jjbitVec21 jjbitVec22 jjbitVec23 jjbitVec24 jjbitVec25 jjbitVec26 jjbitVec27 jjbitVec28 jjbitVec29 jjbitVec3 jjbitVec30 jjbitVec31 jjbitVec32 jjbitVec33 jjbitVec34 jjbitVec35 jjbitVec36 jjbitVec37 jjbitVec38 jjbitVec39 jjbitVec4 jjbitVec40 jjbitVec41 jjbitVec5 jjbitVec6 jjbitVec7 jjbitVec8 jjbitVec9 jjtoSkip jjtoToken SimpleCharStream input_stream stream char curChar int[] jjnextStates jjrounds jjstateSet String[] jjstrLiteralImages lexStateNames int curLexState defaultLexState jjmatchedKind jjmatchedPos jjnewStateCnt jjround lexState pos long active0 active1 |
renderer.setBaseToolTipGenerator( new IntervalCategoryToolTipGenerator("}", DateFormat.getDateInstance())); | [BUG] renderer.setBaseToolTipGenerator(new IntervalCategoryToolTipGenerator("{3} - {4}", DateFormat.getDateInstance())); [CONTEXT] boolean urls) { CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel); DateAxis dateAxis = new DateAxis(dateAxisLabel); CategoryItemRenderer renderer = new GanttRenderer(); if(tooltips) { <extra_id_0> } if(urls) { renderer.setBaseURLGenerator(new StandardCategoryURLGenerator()); } CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, dateAxis, renderer); plot.setOrientation(PlotOrientation.HORIZONTAL); JFreeChart chart = new JFreeChart(title, JFreeChart.DEFAULT_TITLE_FONT, plot, legend); return chart; } [CLASS] ChartFactory [METHOD] createGanttChart [RETURN_TYPE] JFreeChart String title String categoryAxisLabel String dateAxisLabel IntervalCategoryDataset dataset boolean legend boolean tooltips boolean urls [VARIABLES] IntervalCategoryDataset dataset DateAxis dateAxis boolean legend tooltips urls CategoryItemRenderer renderer CategoryAxis categoryAxis String categoryAxisLabel dateAxisLabel title CategoryPlot plot JFreeChart chart |
Node right = left.getNext(); | [BUG] Node right = right.getNext();[ERROR] variable right might not have been initialized [CONTEXT] } } } } if(type == Token.EXPR_RESULT) { tryMinimizeCondition(t, left, n); return; } if(type == Token.RETURN) { tryReduceReturn(t, n); return; } <extra_id_0> if(right == null) { return; } if(type == Token.INSTANCEOF && NodeUtil.isLiteralValue(left) && !NodeUtil.mayHaveSideEffects(right)) { if(NodeUtil.isImmutableValue(left)) { parent.replaceChild(n, new Node(Token.FALSE)); t.getCompiler().reportCodeChange(); return; } [CLASS] FoldConstants 1 2 [METHOD] visit [RETURN_TYPE] void NodeTraversal t Node n Node parent [VARIABLES] Pattern REGEXP_FLAGS_RE AbstractCompiler compiler boolean changes NodeTraversal t DiagnosticType BITWISE_OPERAND_OUT_OF_RANGE DIVIDE_BY_0_ERROR FRACTIONAL_BITWISE_OPERAND INDEX_OUT_OF_BOUNDS_ERROR INVALID_GETELEM_INDEX_ERROR INVALID_REGULAR_EXPRESSION_FLAGS NEGATING_A_NON_NUMBER_ERROR SHIFT_AMOUNT_OUT_OF_BOUNDS double negNum val Node condition left n parent right String className newValue int AND_PRECEDENCE OR_PRECEDENCE intVal result type UnsupportedOperationException ex |
if(fractLen == 1){ | [BUG] if(fractLen == 3) {[ERROR] null testTest [CONTEXT] setFieldValue(period, SECONDS, parseInt(text, position, length)); setFieldValue(period, MILLIS, 0); } else { int wholeValue = parseInt(text, position, fractPos - position - 1); setFieldValue(period, SECONDS, wholeValue); int fractLen = position + length - fractPos; int fractValue; if(fractLen <= 0) { fractValue = 0; } else { if(fractLen >= 3) { fractValue = parseInt(text, fractPos, 3); } else { fractValue = parseInt(text, fractPos, fractLen); <extra_id_0> fractValue *= 100; } else { fractValue *= 10; } } if(wholeValue < 0) { fractValue = -fractValue; } } setFieldValue(period, MILLIS, fractValue); } position += length; [CLASS] PeriodFormatterBuilder SimpleAffix PluralAffix CompositeAffix FieldFormatter Literal Separator Composite [METHOD] parseInto [RETURN_TYPE] int ReadWritablePeriod period String text int position Locale locale [VARIABLES] Locale locale PeriodPrinter[] iPrinters PeriodParser beforeParser iAfterParser iBeforeParser parser ReadWritablePeriod period PeriodParser[] iParsers String finalText iFinalText iPluralText iSingularText iText periodStr pluralText singularText temp text text1 text2 String[] iParsedForms variants int DAYS HOURS MAX_FIELD MILLIS MINUTES MONTHS PRINT_ZERO_ALWAYS PRINT_ZERO_IF_SUPPORTED PRINT_ZERO_NEVER PRINT_ZERO_RARELY_FIRST PRINT_ZERO_RARELY_LAST SECONDS SECONDS_MILLIS SECONDS_OPTIONAL_MILLIS WEEKS YEARS dp fieldType fractLen fractPos fractValue i iFieldType iMaxParsedDigits iMinPrintedDigits iPrintZeroSetting length limit maxDigits maxParsedDigits minDigits minPrinted minPrintedDigits pos position printZeroSetting size sourceLength stopAt suffixPos sum textLength textLength1 textLength2 type value wholeValue PeriodPrinter beforePrinter iAfterPrinter iBeforePrinter printer boolean hasDigits iNotParser iNotPrinter iRejectSignedValues iUseAfter iUseBefore mustParse negative notParser notPrinter rejectSignedValues useAfter useBefore v Literal EMPTY literal char c List elementPairs iElementPairs pairs parserList printerList FieldFormatter[] fieldFormatters iFieldFormatters PeriodFieldAffix iLeft iPrefix iRight iSuffix left prefix right suffix |
return num; | [BUG] return offset;[ERROR] Unexpected end-of-input: was expecting closing quote for a string value testCommentsWithUTF8 [CONTEXT] { int num = digitChars[offset] - '0'; len += offset; if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); if(++offset < len) { num =(num * 10) +(digitChars[offset] - '0'); } } } } } } } } <extra_id_0> } [CLASS] NumberInput [METHOD] parseInt [RETURN_TYPE] int char[] digitChars int offset int len [VARIABLES] String MAX_LONG_STR MIN_LONG_STR_NO_SIGN NASTY_SMALL_DOUBLE boolean long L_BILLION int len num offset char[] digitChars |
processSetCssNameMapping(t, n, parent); | [BUG] processSetCssNameMapping( t, parent, n);[ERROR] null testExternedPropertyName [CONTEXT] } else if("addDependency".equals(methodName)) { CodingConvention convention = compiler.getCodingConvention(); List<String> typeDecls = convention.identifyTypeDeclarationCall(n); if(typeDecls != null) { for(String typeDecl : typeDecls) { compiler.getTypeRegistry().forwardDeclareType(typeDecl); } } parent.replaceChild(n, Node.newNumber(0)); compiler.reportCodeChange(); } else if("setCssNameMapping".equals(methodName)) { <extra_id_0> } } } break; case Token.ASSIGN: if(t.inGlobalScope() && parent.getType() == Token.EXPR_RESULT) { Node nameNode = n.getFirstChild(); String name = nameNode.getQualifiedName(); if(name != null) { if(parent.getBooleanProp(Node.IS_NAMESPACE)) { processProvideFromPreviousPass(t, name, parent); } else { [CLASS] ProcessClosurePrimitives 1 ProvidedNode UnrecognizedRequire [METHOD] visit [RETURN_TYPE] void NodeTraversal t Node n Node parent [VARIABLES] Set exportedVariables NodeTraversal t CheckLevel requiresLevel Node arg externs left n name nameNode node parent providedNode providedParent replacementCandidate replacementCandidateParent requireNode root String GOOG inputName methodName name namespace ns typeDecl ProvidedNode pn provided int dot AbstractCompiler compiler boolean isExpr rewriteNewDateGoogNow DiagnosticType BASE_CLASS_ERROR DUPLICATE_NAMESPACE_ERROR FUNCTION_NAMESPACE_ERROR INVALID_ARGUMENT_ERROR INVALID_PROVIDE_ERROR LATE_PROVIDE_ERROR MISSING_PROVIDE_ERROR NON_STRING_PASSED_TO_SET_CSS_NAME_MAPPING_ERROR NULL_ARGUMENT_ERROR TOO_MANY_ARGUMENTS_ERROR XMODULE_REQUIRE_ERROR error CodingConvention convention JSModule module List typeDecls unrecognizedRequires Map providedNodes |
if(length <= DEFLATER_BLOCK_SIZE){ | [BUG] if(length / DEFLATER_BLOCK_SIZE) {[ERROR] incompatible types [CONTEXT] public void write(byte[] b, int offset, int length) throws IOException { if(entry.getMethod() == DEFLATED) { if(length > 0) { if(!def.finished()) { <extra_id_0> def.setInput(b, offset, length); deflateUntilInputIsNeeded(); } else { final int fullblocks = length / DEFLATER_BLOCK_SIZE; for(int i = 0; i < fullblocks; i++) { def.setInput(b, offset + i * DEFLATER_BLOCK_SIZE, DEFLATER_BLOCK_SIZE); deflateUntilInputIsNeeded(); } final int done = fullblocks * DEFLATER_BLOCK_SIZE; if(done < length) { def.setInput(b, offset + done, length - done); deflateUntilInputIsNeeded(); } } } } } else { writeOut(b, offset, length); written += length; } crc.update(b, offset, length); } [CLASS] ZipArchiveOutputStream UnicodeExtraFieldPolicy [METHOD] write [RETURN_TYPE] void byte[] b int offset int length [VARIABLES] ZipEncoding zipEncoding UnicodeExtraFieldPolicy ALWAYS NEVER NOT_ENCODEABLE b createUnicodeExtraFields CRC32 crc OutputStream o out String DEFAULT_ENCODING comment encoding n name int BUFFER_SIZE BYTE_MASK DEFAULT_COMPRESSION DEFLATED DEFLATER_BLOCK_SIZE EFS_FLAG SHORT STORED WORD done fullblocks i length level method offset long cdLength cdOffset dataStart localDataStart realCrc save size written byte[] CFH_SIG DD_SIG EOCD_SIG LFH_SIG LZERO ZERO b buf boolean b fallbackToUTF8 hasCompressionLevelChanged useEFS Deflater def RandomAccessFile _raf raf ZipArchiveEntry entry ze List entries Map offsets |
Preconditions.checkState(childCount == 1); | [BUG] Preconditions.checkState( childCount == 0);Preconditions.checkState( childCount == 1);[ERROR] null testRegularExpressions [CONTEXT] if(childCount == 2) { add(regexp + last.getString()); } else { <extra_id_0> add(regexp); } [CLASS] CodeGenerator Context [METHOD] add [RETURN_TYPE] void Node n Context context [VARIABLES] Context BEFORE_DANGLING_ELSE IN_FOR_INIT_CLAUSE OTHER PRESERVE_BLOCK START_OF_EXPR STATEMENT context rhsContext boolean ambiguousElseClause funcNeedsParens hasElse needsParens stripBlock validation Node c catchblock first last n next CodeConsumer cc consumer String o opstr regexp CharsetEncoder outputCharsetEncoder int childCount p postProp precedence type char[] HEX_CHARS |
double uvalue; | [BUG] double total = 0.0;double uvalue;[ERROR] org/jfree/chart/JFreeChartInfo testCloning [CONTEXT] public static Range iterateDomainBounds(XYDataset dataset, boolean includeInterval) { if(dataset == null) { throw new IllegalArgumentException("Null 'dataset' argument."); } double minimum = Double.POSITIVE_INFINITY; double maximum = Double.NEGATIVE_INFINITY; int seriesCount = dataset.getSeriesCount(); double lvalue; <extra_id_0> if(includeInterval && dataset instanceof IntervalXYDataset) { IntervalXYDataset intervalXYData =(IntervalXYDataset) dataset; for(int series = 0; series < seriesCount; series++) { int itemCount = dataset.getItemCount(series); for(int item = 0; item < itemCount; item++) { lvalue = intervalXYData.getStartXValue(series, item); uvalue = intervalXYData.getEndXValue(series, item); minimum = Math.min(minimum, lvalue); maximum = Math.max(maximum, uvalue); } } } else { for(int series = 0; series < seriesCount; series++) { int itemCount = dataset.getItemCount(series); [CLASS] DatasetUtilities [METHOD] iterateDomainBounds [RETURN_TYPE] Range XYDataset dataset boolean includeInterval [VARIABLES] boolean includeInterval double lvalue maximum minimum uvalue IntervalXYDataset intervalXYData XYDataset dataset int item itemCount series seriesCount |
if(n2 != null){ | [BUG] if(n2.doubleValue() + yy1 / 2.0) {[ERROR] incompatible types [CONTEXT] } double yy1 = value.doubleValue(); double yy0 = 0.0; if(column > 0) { Number n0 = dataset.getValue(row, column - 1); if(n0 != null) { yy0 =(n0.doubleValue() + yy1) / 2.0; } } double yy2 = 0.0; if(column < dataset.getColumnCount() - 1) { Number n2 = dataset.getValue(row, column + 1); <extra_id_0> yy2 =(n2.doubleValue() + yy1) / 2.0; } } RectangleEdge edge = plot.getRangeAxisEdge(); float y0 =(float) rangeAxis.valueToJava2D(yy0, dataArea, edge); float y1 =(float) rangeAxis.valueToJava2D(yy1, dataArea, edge); float y2 =(float) rangeAxis.valueToJava2D(yy2, dataArea, edge); float yz =(float) rangeAxis.valueToJava2D(0.0, dataArea, edge); g2.setPaint(getItemPaint(row, column)); g2.setStroke(getItemStroke(row, column)); GeneralPath area = new GeneralPath(); [CLASS] AreaRenderer [METHOD] drawItem [RETURN_TYPE] void Graphics2D g2 CategoryItemRendererState state Rectangle2D dataArea CategoryPlot plot CategoryAxis domainAxis ValueAxis rangeAxis CategoryDataset dataset int row int column int pass [VARIABLES] PlotOrientation orientation GeneralPath area CategoryItemRendererState state double yy0 yy1 yy2 Rectangle2D dataArea float x0 x1 x2 y0 y1 y2 yz long serialVersionUID CategoryPlot plot int column count pass row Graphics2D g2 boolean Number n0 n2 value CategoryAxis domainAxis EntityCollection entities ValueAxis rangeAxis CategoryDataset dataset AreaRendererEndType endType type RectangleEdge axisEdge edge |
value = valueAccum.toString(); | [BUG] value = valueAccum.tochar();[ERROR] cannot find symbol [CONTEXT] } else if(tq.matchChomp(DQ)) { value = tq.chompTo(DQ); } else { StringBuilder valueAccum = new StringBuilder(); while(!tq.matchesAny("<","/>",">") && !tq.matchesWhitespace() && !tq.isEmpty()) { valueAccum.append(tq.consume()); } <extra_id_0> } [CLASS] Parser [METHOD] parseAttribute [RETURN_TYPE] Attribute [VARIABLES] TokenQueue tq boolean StringBuilder valueAccum String DQ SQ baseUri bodyHtml data href html key tagName value Tag bodyTag headTag htmlTag tag textareaTag titleTag Document doc LinkedList stack |
bottom.moveTo(( float)p00.getX() ,(float)p00.getY()); | [BUG] top.lineTo((float) p03.getX(),(float) p03.getY());bottom.moveTo((float) p00.getX(),(float) p00.getY());[ERROR] null testDrawWithNullInfo [CONTEXT] GeneralPath front = new GeneralPath(); front.moveTo((float) p0.getX(),(float) p0.getY()); front.lineTo((float) p1.getX(),(float) p1.getY()); front.lineTo((float) p01.getX(),(float) p01.getY()); front.lineTo((float) p00.getX(),(float) p00.getY()); front.closePath(); GeneralPath top = new GeneralPath(); top.moveTo((float) p0.getX(),(float) p0.getY()); top.lineTo((float) p1.getX(),(float) p1.getY()); top.lineTo((float) p2.getX(),(float) p2.getY()); top.lineTo((float) p3.getX(),(float) p3.getY()); top.closePath(); GeneralPath bottom = new GeneralPath(); <extra_id_0> bottom.lineTo((float) p01.getX(),(float) p01.getY()); bottom.lineTo((float) p02.getX(),(float) p02.getY()); bottom.lineTo((float) p03.getX(),(float) p03.getY()); bottom.closePath(); result[0] = bottom; result[1] = back; result[2] = left; result[3] = right; result[4] = top; result[5] = front; if(inverted) { result[0] = top; result[4] = bottom; } [CLASS] StackedBarRenderer3D [METHOD] createVerticalBlock [RETURN_TYPE] Shape[] double x0 double width double y0 double y1 boolean inverted [VARIABLES] boolean asPercentages drawOutlines inverted neg renderAsPercentages Shape[] result GeneralPath back bottom front left right top Point2D p0 p00 p01 p02 p03 p1 p2 p3 long serialVersionUID double width x0 y0 y1 |
final Method method = targetClass.getMethod( methodName, method.getParameterTypes()); | [BUG] final Method method = targetClass.getMethod(methodName, proxy.getParameterTypes()); [CONTEXT] setNamePrefix(targetClass.getName()); Object key = KEY_FACTORY.newInstance(targetClass, methodName, iface); return(MethodDelegate)super.create(key); } protected Object firstInstance(Class type) { return((MethodDelegate)ReflectUtils.newInstance(type)).newInstance(target); } protected Object nextInstance(Object instance) { return((MethodDelegate)instance).newInstance(target); } public void generateClass(ClassVisitor v) throws NoSuchMethodException { Method proxy = ReflectUtils.findInterfaceMethod(iface); <extra_id_0> if(!proxy.getReturnType().isAssignableFrom(method.getReturnType())) { throw new IllegalArgumentException("incompatible return types"); } MethodInfo methodInfo = ReflectUtils.getMethodInfo(method); boolean isStatic = TypeUtils.isStatic(methodInfo.getModifiers()); if((target == null) ^ isStatic) { throw new IllegalArgumentException("Static method" +(isStatic ?"not" :"") +"expected"); } ClassEmitter ce = new ClassEmitter(v); CodeEmitter e; ce.begin_class(Constants.V1_2, Constants.ACC_PUBLIC, [CLASS] Generator [METHOD] generateClass [RETURN_TYPE] void ClassVisitor v [VARIABLES] CodeEmitter e Type METHOD_DELEGATE boolean isStatic Signature NEW_INSTANCE ClassEmitter ce Object instance key target Class iface targetClass type MethodInfo methodInfo proxied String methodName ClassVisitor v Method method proxy Source SOURCE |
enlarge( b + byteLength); | [BUG] enlarge(2 + byteLength); [CONTEXT] int byteLength = i; for(int j = i; j < charLength; ++j) { c = s.charAt(j); if(c >= '\001' && c <= '\177') { byteLength++; } else if(c > '\u07FF') { byteLength += 3; } else { byteLength += 2; } } data[length] =(byte)(byteLength >>> 8); data[length + 1] =(byte) byteLength; if(length + 2 + byteLength > data.length) { length = len; <extra_id_0> data = this.data; } for(int j = i; j < charLength; ++j) { c = s.charAt(j); if(c >= '\001' && c <= '\177') { data[len++] =(byte) c; } else if(c > '\u07FF') { data[len++] =(byte)(0xE0 | c >> 12 & 0xF); data[len++] =(byte)(0x80 | c >> 6 & 0x3F); data[len++] =(byte)(0x80 | c & 0x3F); } else { data[len++] =(byte)(0xC0 | c >> 6 & 0x1F); data[len++] =(byte)(0x80 | c & 0x3F); } } [CLASS] ByteVector [METHOD] putUTF8 [RETURN_TYPE] ByteVector String s [VARIABLES] byte[] data char c String s boolean int b b1 b2 byteLength charLength i initialSize j len length s |
int oldCount = keyCount; | [BUG] int writtenKeyCount = keyCount;int oldCount = keyCount;[NO-ERROR] [CONTEXT] } int N = 1 << power; int[] old = keys; int oldShift = ivaluesShift; if(oldShift == 0 && !ensureIntSpace) { keys = new int[N]; } else { ivaluesShift = N; keys = new int[N * 2]; } for(int i = 0; i != N; ++i) { keys[i] = EMPTY; } Object[] oldValues = values; if(oldValues != null) { values = new Object[N]; } <extra_id_0> occupiedCount = 0; if(oldCount != 0) { keyCount = 0; for(int i = 0, remaining = oldCount; remaining != 0; ++i) { int key = old[i]; if(key != EMPTY && key != DELETED) { int index = insertNewKey(key); if(oldValues != null) { values[index] = oldValues[i]; } if(oldShift != 0) { keys[ivaluesShift + index] = old[oldShift + i]; } --remaining; } [CLASS] UintMap [METHOD] rehashTable [RETURN_TYPE] void boolean ensureIntSpace [VARIABLES] int[] keys old result tmp boolean check ensureIntSpace long serialVersionUID int A DELETED EMPTY N defaultValue entry firstIndex fraction i index initialCapacity ivaluesShift key keyCount mask minimalCapacity n occupiedCount oldCount oldShift power remaining shift step value Object[] oldValues values |
if(ac == 3){ | [BUG] if(out == 3) {[ERROR] cannot find symbol out [CONTEXT] return new Double(Math.round(v)); } private Object functionFormatNumber(EvalContext context) { int ac = getArgumentCount(); if(ac != 2 && ac != 3) { assertArgCount(2); } double number = InfoSetUtil.doubleValue(getArg1().computeValue(context)); String pattern = InfoSetUtil.stringValue(getArg2().computeValue(context)); DecimalFormatSymbols symbols = null; <extra_id_0> String symbolsName = InfoSetUtil.stringValue(getArg3().computeValue(context)); symbols = context.getJXPathContext().getDecimalFormatSymbols(symbolsName); } else { NodePointer pointer = context.getCurrentNodePointer(); Locale locale; if(pointer != null) { locale = pointer.getLocale(); } else { locale = context.getJXPathContext().getLocale(); } symbols = new DecimalFormatSymbols(locale); [CLASS] CoreFunction [METHOD] functionFormatNumber [RETURN_TYPE] Object EvalContext context [VARIABLES] Locale locale boolean DecimalFormatSymbols symbols double number DecimalFormat format EvalContext context String pattern symbolsName NodePointer pointer Double ZERO int ac count functionCode i in index inx old out phase |
} else if(to == Type.FLOAT_TYPE){ | [BUG] } else {[NO-ERROR] [CONTEXT] mv.visitInsn(Constants.D2I); cast_numeric(Type.INT_TYPE, to); } } else if(from == Type.FLOAT_TYPE) { if(to == Type.DOUBLE_TYPE) { mv.visitInsn(Constants.F2D); } else if(to == Type.LONG_TYPE) { mv.visitInsn(Constants.F2L); } else { mv.visitInsn(Constants.F2I); cast_numeric(Type.INT_TYPE, to); } } else if(from == Type.LONG_TYPE) { if(to == Type.DOUBLE_TYPE) { mv.visitInsn(Constants.L2D); <extra_id_0> mv.visitInsn(Constants.L2F); } else { mv.visitInsn(Constants.L2I); cast_numeric(Type.INT_TYPE, to); } } else { if(to == Type.BYTE_TYPE) { mv.visitInsn(Constants.I2B); } else if(to == Type.CHAR_TYPE) { mv.visitInsn(Constants.I2C); } else if(to == Type.DOUBLE_TYPE) { mv.visitInsn(Constants.I2D); } else if(to == Type.FLOAT_TYPE) { mv.visitInsn(Constants.I2F); } else if(to == Type.LONG_TYPE) { [CLASS] CodeEmitter State [METHOD] cast_numeric [RETURN_TYPE] void Type from Type to [VARIABLES] Type from to boolean State state Signature BOOLEAN_VALUE CHAR_VALUE CSTRUCT_NULL CSTRUCT_STRING DOUBLE_VALUE FLOAT_VALUE INT_VALUE LONG_VALUE sig ClassEmitter ce Type[] argumentTypes exceptionTypes int ADD AND DIV EQ GE GT LE LT MUL NE NEG OR REM SUB USHR XOR access intOp jumpmode localOffset mode op ClassInfo classInfo |
return(( Collection<?>)iterable).size(); | [BUG] return(( Collection<?>) iterable).size() + 7;[NO-ERROR] [CONTEXT] public static int size(final Iterable<?> iterable) { if(iterable instanceof Collection<?>) { <extra_id_0> } else { return IteratorUtils.size(emptyIteratorIfNull(iterable)); } } [CLASS] IterableUtils 1 1 2 3 4 5 1 6 7 8 9 10 [METHOD] size [RETURN_TYPE] int Iterable<?> iterable [VARIABLES] boolean Iterable iterable |
logSum -= Math.log(( double)i); | [BUG] [NO-ERROR] [CONTEXT] public static double binomialCoefficientLog(final int n, final int k) { if(n < k) { throw new IllegalArgumentException("must have n >= k for binomial coefficient(n,k)"); } if(n < 0) { throw new IllegalArgumentException("must have n >= 0 for binomial coefficient(n,k)"); } if((n == k) ||(k == 0)) { return 0; } if((k == 1) ||(k == n - 1)) { return Math.log((double)n); } double logSum = 0; for(int i = k + 1; i <= n; i++) { logSum += Math.log((double)i); } for(int i = 2; i <= n - k; i++) { <extra_id_0> } return logSum; [CLASS] MathUtils [METHOD] binomialCoefficientLog [RETURN_TYPE] double final int n final int k [VARIABLES] short NS PS ZS boolean byte NB PB ZB int i k n double logSum |
if(zone == DateTimeZone.UTC){ | [BUG] if(zone == getZone()) {[ERROR] Types array must be in order largest-smallest: year < monthOfYear testEqualsHashCode [CONTEXT] MutableDateTime mdt = lowerLimit.toMutableDateTime(); mdt.setZoneRetainFields(zone); lowerLimit = mdt.toDateTime(); } DateTime upperLimit = iUpperLimit; if(upperLimit != null) { MutableDateTime mdt = upperLimit.toMutableDateTime(); mdt.setZoneRetainFields(zone); upperLimit = mdt.toDateTime(); } LimitChronology chrono = getInstance(getBase().withZone(zone), lowerLimit, upperLimit); <extra_id_0> iWithUTC = chrono; } return chrono; } public long getDateTimeMillis(int year, int monthOfYear, int dayOfMonth, int millisOfDay) throws IllegalArgumentException { long instant = getBase().getDateTimeMillis(year, monthOfYear, dayOfMonth, millisOfDay); checkLimits(instant,"resulting"); return instant; } [CLASS] LimitChronology LimitException LimitDurationField LimitDateTimeField [METHOD] withZone [RETURN_TYPE] Chronology DateTimeZone zone [VARIABLES] boolean iIsLow isLow LimitChronology chrono iWithUTC MutableDateTime mdt DurationField durationField field iDurationField iLeapDurationField iRangeDurationField leapDurationField rangeDurationField long serialVersionUID DateTime iLowerLimit iUpperLimit lowerLimit upperLimit DateTimeZone zone |
TypeResolverBuilder<?> b = ai.findTypeResolver(config, ac, baseType); | [BUG] TypeResolverBuilder<?> b = config.findTypeResolver( ai, ac, baseType);[ERROR] cannot find symbol [CONTEXT] { Class<?> cls = baseType.getRawClass(); BeanDescription bean = config.introspectClassAnnotations(cls); AnnotatedClass ac = bean.getClassInfo(); AnnotationIntrospector ai = config.getAnnotationIntrospector(); <extra_id_0> Collection<NamedType> subtypes = null; if(b == null) { b = config.getDefaultTyper(baseType); if(b == null) { return null; } } else { subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(ac, config, ai); } if((b.getDefaultImpl() == null) && baseType.isAbstract()) { JavaType defaultType = mapAbstractType(config, baseType); if(defaultType != null && defaultType.getRawClass() != baseType.getRawClass()) { b = b.defaultImpl(defaultType.getRawClass()); } } return b.buildTypeDeserializer(config, baseType, subtypes); } [CLASS] BasicDeserializerFactory [METHOD] findTypeDeserializer [RETURN_TYPE] TypeDeserializer DeserializationConfig config JavaType baseType [VARIABLES] JavaType baseType defaultType boolean DeserializerFactoryConfig _factoryConfig config HashMap _collectionFallbacks _mapFallbacks AnnotatedClass ac BeanDescription bean TypeResolverBuilder b AnnotationIntrospector ai Collection subtypes Class CLASS_CHAR_BUFFER CLASS_ITERABLE CLASS_OBJECT CLASS_STRING cls collectionClass currClass enumClass fallback instClass kt mapClass nextCls nodeClass prevCls raw returnType type DeserializationConfig config |
_collList = Arrays.copyOf(old, old.length * 2); | [BUG] _collList = Arrays.copyOf( old.length * 2);[ERROR] no suitable method found for copyOf(int) [CONTEXT] private void expandCollision() { final Bucket[] old = _collList; <extra_id_0> } [CLASS] BytesToNameCanonicalizer TableInfo Bucket [METHOD] expandCollision [RETURN_TYPE] void [VARIABLES] boolean _collListShared _intern _mainHashShared _mainNamesShared _needRehash canonicalize intern Bucket[] _collList buckets collList old oldBuckets Bucket _next bucket curr newB next BytesToNameCanonicalizer _parent parent src AtomicReference _tableInfo int[] _mainHash mainHash old oldMainHash quads result int DEFAULT_TABLE_SIZE INITIAL_COLLISION_LEN LAST_VALID_BUCKET MAX_COLL_CHAIN_FOR_REUSE MAX_COLL_CHAIN_LENGTH MAX_ENTRIES_FOR_REUSE MAX_TABLE_SIZE MIN_HASH_SIZE MULT MULT2 MULT3 _collCount _collEnd _count _hashSeed _length _longestCollisionList _mainHashMask bestCount bestIx blen bucket childCount collCount collEnd count curr entryValue firstQuad hash hashQuarter hashSeed hashSize i ix len longestCollisionList mainHashMask maxColl newLen oldEnd q1 q2 qlen secondQuad seed symbolsSeen val x Name[] _mainNames mainNames old oldNames Name _name name symbol |
public void setFieldName(String n){ _fieldName = n; } | [BUG] public void setFieldName( char n) { _fieldName = n; }[ERROR] incompatible types [CONTEXT] _from = from; _index = index; } public void setFrom(Object o) { _from = o; } <extra_id_0> public void setIndex(int ix) { _index = ix; } public Object getFrom() { return _from; } public String getFieldName() { return _fieldName; } public int getIndex() { return _index; } [CLASS] JsonMappingException Reference [METHOD] setFieldName [RETURN_TYPE] void String n [VARIABLES] Object _from from o String _fieldName fieldName msg n boolean long serialVersionUID int MAX_REFS_TO_LIST _index index LinkedList _path |
top.lineTo(( float)p03.getX() ,(float)p03.getY()); | [BUG] bottom.lineTo((float) p2.getX(),(float) p2.getY());top.lineTo((float) p03.getX(),(float) p03.getY());[ERROR] null testDrawWithNullInfo [CONTEXT] Point2D p2 = new Point2D.Double(p1.getX() + getXOffset(), p1.getY() - getYOffset()); Point2D p3 = new Point2D.Double(p0.getX() + getXOffset(), p0.getY() - getYOffset()); GeneralPath bottom = new GeneralPath(); bottom.moveTo((float) p1.getX(),(float) p1.getY()); bottom.lineTo((float) p01.getX(),(float) p01.getY()); bottom.lineTo((float) p02.getX(),(float) p02.getY()); bottom.lineTo((float) p2.getX(),(float) p2.getY()); bottom.closePath(); GeneralPath top = new GeneralPath(); top.moveTo((float) p0.getX(),(float) p0.getY()); top.lineTo((float) p00.getX(),(float) p00.getY()); <extra_id_0> top.lineTo((float) p3.getX(),(float) p3.getY()); top.closePath(); GeneralPath back = new GeneralPath(); back.moveTo((float) p2.getX(),(float) p2.getY()); back.lineTo((float) p02.getX(),(float) p02.getY()); back.lineTo((float) p03.getX(),(float) p03.getY()); back.lineTo((float) p3.getX(),(float) p3.getY()); back.closePath(); GeneralPath front = new GeneralPath(); front.moveTo((float) p0.getX(),(float) p0.getY()); front.lineTo((float) p1.getX(),(float) p1.getY()); front.lineTo((float) p01.getX(),(float) p01.getY()); front.lineTo((float) p00.getX(),(float) p00.getY()); [CLASS] StackedBarRenderer3D [METHOD] createHorizontalBlock [RETURN_TYPE] Shape[] double x0 double width double y0 double y1 boolean inverted [VARIABLES] boolean asPercentages drawOutlines inverted neg renderAsPercentages Shape[] result GeneralPath back bottom front left right top Point2D p0 p00 p01 p02 p03 p1 p2 p3 long serialVersionUID double width x0 y0 y1 |
} else if(d >= Void.TYPE) { | [BUG] } else if(d == Void.TYPE){ [CONTEXT] } private static void getDescriptor(final StringBuffer buf, final Class c) { Class d = c; while(true) { if(d.isPrimitive()) { char car; if(d == Integer.TYPE) { car = 'I'; <extra_id_0> car = 'V'; } else if(d == Boolean.TYPE) { car = 'Z'; } else if(d == Byte.TYPE) { car = 'B'; } else if(d == Character.TYPE) { car = 'C'; } else if(d == Short.TYPE) { car = 'S'; } else if(d == Double.TYPE) { car = 'D'; } else if(d == Float.TYPE) { car = 'F'; } else /* if(d == Long.TYPE) */{ car = 'J'; [CLASS] Type [METHOD] getDescriptor [RETURN_TYPE] void StringBuffer buf Class c [VARIABLES] Type BOOLEAN_TYPE BYTE_TYPE CHAR_TYPE DOUBLE_TYPE FLOAT_TYPE INT_TYPE LONG_TYPE SHORT_TYPE VOID_TYPE returnType StringBuffer buf boolean char car Class c d String name int ARRAY BOOLEAN BYTE CHAR DOUBLE FLOAT INT LONG OBJECT SHORT VOID i len off size sort char[] buf |
if(isLineBreak(encapsulator)) { | [BUG] if(isLineBreak( escape)){[ERROR] null testValidation [CONTEXT] public CSVFormat withEncapsulator(char encapsulator) { <extra_id_0> throw new IllegalArgumentException("The encapsulator cannot be a line break"); } return new CSVFormat(delimiter, encapsulator, commentStart, escape, surroundingSpacesIgnored, emptyLinesIgnored, lineSeparator, header); } [CLASS] CSVFormat [METHOD] withEncapsulator [RETURN_TYPE] CSVFormat char encapsulator [VARIABLES] char DISABLED c commentStart delimiter encapsulator escape CSVFormat DEFAULT EXCEL MYSQL PRISTINE RFC4180 TDF boolean emptyLinesIgnored surroundingSpacesIgnored String CRLF lineSeparator String[] header |
button.addActionListener(this); | [BUG] button.setActionCommand("OutlineStroke");button.addActionListener( this);[ERROR] expected:<org.jfree.chart.block.BlockContainer@5ef04b5> but was:<org.jfree.chart.block.BlockContainer@573fd745> testSerialization [CONTEXT] interior.add( new JLabel(localizationResources.getString("Outline_stroke"))); JButton button = new JButton(localizationResources.getString("Select...")); button.setActionCommand("OutlineStroke"); <extra_id_0> interior.add(this.outlineStrokeSample); interior.add(button); interior.add( new JLabel(localizationResources.getString("Outline_Paint"))); button = new JButton(localizationResources.getString("Select...")); button.setActionCommand("OutlinePaint"); button.addActionListener(this); interior.add(this.outlinePaintSample); interior.add(button); interior.add( new JLabel(localizationResources.getString("Background_paint"))); [CLASS] DefaultPlotEditor [METHOD] <init> [RETURN_TYPE] Plot) Plot plot [VARIABLES] LineAndShapeRenderer r JPanel appearance general interior panel PlotOrientation plotOrientation JComboBox orientationCombo CategoryItemRenderer renderer DefaultAxisEditor domainAxisPropertyPanel rangeAxisPropertyPanel Plot plot JTabbedPane tabs JButton button String[] orientationNames int ORIENTATION_HORIZONTAL ORIENTATION_VERTICAL index JCheckBox drawLinesCheckBox drawShapesCheckBox boolean isVertical PaintSample backgroundPaintSample outlinePaintSample StandardXYItemRenderer r RectangleInsets plotInsets ResourceBundle localizationResources StrokeSample outlineStrokeSample XYItemRenderer renderer Boolean drawLines drawShapes StrokeSample[] availableStrokeSamples Axis domainAxis rangeAxis |
out.defaultWriteObject(); | [BUG] [NO-ERROR] [CONTEXT] private void writeObject(final ObjectOutputStream out) throws IOException { <extra_id_0> doWriteObject(out); [CLASS] ReferenceMap [METHOD] writeObject [RETURN_TYPE] void ObjectOutputStream out [VARIABLES] ObjectOutputStream out long serialVersionUID boolean |
super.visit( access, name, signature, superName, interfaces); | [BUG] super.visit(version, access, name, signature, superName, interfaces); [CONTEXT] public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) { className = name.replace('/', '.'); this.superName = superName.replace('/', '.'); <extra_id_0> } [CLASS] DebuggingClassWriter 1 [METHOD] visit [RETURN_TYPE] void int version int access String name String signature String superName String[] interfaces [VARIABLES] boolean traceEnabled String DEBUG_LOCATION_PROPERTY className debugLocation name signature superName String[] interfaces int access version |
numElements = index + 1; | [BUG] numElements = 0;numElements = index + 1;[ERROR] Incorrect inverse cumulative probability value returned for 0.05 expected:<4> but was:<3> testInverseCumulativeProbabilities [CONTEXT] public synchronized void setElement(int index, double value) { if(index < 0) { String msg ="Cannot set an element at a negative index"; throw new ArrayIndexOutOfBoundsException(msg); } if(index + 1 > numElements) { <extra_id_0> } if((startIndex + index) >= internalArray.length) { expandTo(startIndex +(index + 1)); } internalArray[startIndex + index] = value; } [CLASS] ResizableDoubleArray [METHOD] setElement [RETURN_TYPE] void int index double value [VARIABLES] boolean double[] elementArray internalArray tempArray double value String msg float contractionCritera contractionCriteria expansionFactor long serialVersionUID int ADDITIVE_MODE MULTIPLICATIVE_MODE expansionMode i index initialCapacity newSize numElements size startIndex |
if(categoryCount != ends[0].length){ | [BUG] if(categoryCount <= ends[0].length) {[ERROR] org/jfree/chart/JFreeChartInfo testCloning [CONTEXT] throw new IllegalArgumentException("The number of series keys does not" +"match the number of series in the data."); } this.seriesKeys = seriesKeys; } else { String prefix = resources.getString("series.default-prefix") +""; this.seriesKeys = generateKeys(seriesCount, prefix); } int categoryCount = starts[0].length; <extra_id_0> String errMsg ="DefaultIntervalCategoryDataset: the" +"number of categories in the start value" +"dataset does not match the number of" +"categories in the end value dataset."; throw new IllegalArgumentException(errMsg); } if(categoryKeys != null) { if(categoryKeys.length != categoryCount) { throw new IllegalArgumentException("The number of category keys does not match" +"the number of categories in the data."); } this.categoryKeys = categoryKeys; } else { [CLASS] DefaultIntervalCategoryDataset [METHOD] <init> [RETURN_TYPE] Number[][]) Comparable[] seriesKeys Comparable[] categoryKeys Number[][] starts Number[][] ends [VARIABLES] Number[][] endData ends startData starts ResourceBundle resources String baseName errMsg prefix boolean int categoryCount seriesCount Comparable[] categoryKeys seriesKeys |
stackSize = size; | [BUG] stackSize = localVarCount;[NO-ERROR] [CONTEXT] if(opcode == Opcodes.RET) { currentBlock.status |= Label.RET; currentBlock.inputStackTop = stackSize; noSuccessor(); } else { // xLOAD or xSTORE int size = stackSize + Frame.SIZE[opcode]; if(size > maxStackSize) { maxStackSize = size; } <extra_id_0> } [CLASS] MethodWriter [METHOD] visitVarInsn [RETURN_TYPE] void final int opcode final int var [VARIABLES] Attribute attr attrs cattrs MethodWriter next AnnotationWriter anns aw ianns Label currentBlock labels previousBlock Handler firstHandler lastHandler int[] exceptions frame previousFrame String desc descriptor name signature int ACC_CONSTRUCTOR APPEND_FRAME CHOP_FRAME FRAMES FULL_FRAME MAXS NOTHING RESERVED SAME_FRAME SAME_FRAME_EXTENDED SAME_LOCALS_1_STACK_ITEM_FRAME SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED access classReaderLength classReaderOffset compute delta desc exceptionCount frameCount frameIndex handlerCount i lineNumberCount localVarCount localVarTypeCount maxLocals maxStack maxStackSize n nLocal nStack name opcode operand opt parameter previousFrameOffset size stackSize subroutines synthetics type var ClassWriter cw ByteVector annd bv code lineNumber localVar localVarType stackMap AnnotationWriter[] ipanns panns boolean computeFrames computeMaxs resize visible |
if(!this.seriesParameterName.equals(that.seriesParameterName)) { | [BUG] if(!this.seriesParameterName.equals( seriesParameterName)){[ERROR] expected:<org.jfree.chart.JFreeChart@f2a0b8e> but was:<org.jfree.chart.JFreeChart@58ceff1> testSerialization1 [CONTEXT] public boolean equals(Object obj) { if(obj == this) { return true; } if(!(obj instanceof TimeSeriesURLGenerator)) { return false; } TimeSeriesURLGenerator that =(TimeSeriesURLGenerator) obj; if(!this.dateFormat.equals(that.dateFormat)) { return false; } if(!this.itemParameterName.equals(that.itemParameterName)) { return false; } if(!this.prefix.equals(that.prefix)) { return false; } <extra_id_0> return false; } return true; } [CLASS] TimeSeriesURLGenerator [METHOD] equals [RETURN_TYPE] boolean Object obj [VARIABLES] Object obj String itemParameterName prefix result s seriesParameterName xValue boolean long serialVersionUID x DateFormat dateFormat TimeSeriesURLGenerator that |
out.write('r'); | [BUG] out.write( 't');out.write( 'r');[ERROR] escapeJava(String) failed expected:< testEscapeJava [CONTEXT] break; case '\n': out.write('\\'); out.write('n'); break; case '\t': out.write('\\'); out.write('t'); break; case '\f': out.write('\\'); out.write('f'); break; case '\r': out.write('\\'); <extra_id_0> break; default : if(ch > 0xf) { out.write("\\u00" + hex(ch)); } else { out.write("\\u000" + hex(ch)); } break; } } else { switch(ch) { case '\'': if(escapeSingleQuote) { out.write('\\'); } [CLASS] StringEscapeUtils [METHOD] escapeJavaStyleString [RETURN_TYPE] void Writer out String str boolean escapeSingleQuote [VARIABLES] boolean escapeSingleQuote char ch String str Writer out int i sz |
txt = txt.replaceAll("y","3"); | [BUG] txt = txt.replaceAll("y","");[ERROR] expected:<76> but was:<79> testRfc2045Section6Dot8ChunkSizeDefinition [CONTEXT] txt = txt.replaceAll("x","k"); txt = txt.replaceAll("v","f"); txt = txt.replaceAll("dg","2g"); txt = txt.replaceAll("tio","sio"); txt = txt.replaceAll("tia","sia"); txt = txt.replaceAll("d","t"); txt = txt.replaceAll("ph","fh"); txt = txt.replaceAll("b","p"); txt = txt.replaceAll("sh","s2"); txt = txt.replaceAll("z","s"); txt = txt.replaceAll("^[aeiou]","A"); txt = txt.replaceAll("[aeiou]","3"); txt = txt.replaceAll("j","y");// 2.0 only txt = txt.replaceAll("^y3","Y3"); // 2.0 only txt = txt.replaceAll("^y","A"); // 2.0 only <extra_id_0> txt = txt.replaceAll("3gh3","3kh3"); txt = txt.replaceAll("gh","22"); txt = txt.replaceAll("g","k"); txt = txt.replaceAll("s+","S"); txt = txt.replaceAll("t+","T"); txt = txt.replaceAll("p+","P"); txt = txt.replaceAll("k+","K"); txt = txt.replaceAll("f+","F"); txt = txt.replaceAll("m+","M"); txt = txt.replaceAll("n+","N"); txt = txt.replaceAll("w3","W3"); txt = txt.replaceAll("wh3","Wh3"); txt = txt.replaceAll("w$","3"); // 2.0 only [CLASS] Caverphone [METHOD] caverphone [RETURN_TYPE] String String txt [VARIABLES] boolean String txt |
JsonElement jsonChild = jsonObject.get(fName); | [BUG] JsonElement jsonChild = fName.get( jsonObject);[ERROR] cannot find symbol [CONTEXT] public void visitObjectField(FieldAttributes f, Type typeOfF, Object obj) { try { if(!json.isJsonObject()) { throw new JsonParseException("Expecting object found:" + json); } JsonObject jsonObject = json.getAsJsonObject(); String fName = getFieldName(f); <extra_id_0> if(jsonChild != null) { Object child = visitChildAsObject(typeOfF, jsonChild); f.set(obj, child); } else { f.set(obj, null); } } catch(IllegalAccessException e) { throw new RuntimeException(e); } } [CLASS] JsonObjectDeserializationVisitor [METHOD] visitObjectField [RETURN_TYPE] void FieldAttributes f Type typeOfF Object obj [VARIABLES] Type typeOfF boolean JsonElement jsonChild JsonObject jsonObject Object child obj String fName FieldAttributes f IllegalAccessException e |
return new MethodProperty(this, _annotated.getAnnotated()); | [BUG] [ERROR] expected:<...> but was:<null> testMapWithFactory [CONTEXT] Object readResolve() { <extra_id_0> [CLASS] MethodProperty [METHOD] readResolve [RETURN_TYPE] Object [VARIABLES] Method _setter m boolean AnnotatedMethod _annotated method long serialVersionUID |
private static final short MERGESORT_THRESHOLD = 12; | [BUG] private static final int MERGESORT_THRESHOLD = 12; [CONTEXT] package org.mockito.cglib.util; import java.util.*; abstract class SorterTemplate { <extra_id_0> private static final int QUICKSORT_THRESHOLD = 7; abstract protected void swap(int i, int j); abstract protected int compare(int i, int j); [CLASS] SorterTemplate [VARIABLES] |
buf.append(");\n\n"); | [BUG] buf.append( visible);buf.append(");\n\n");[NO-ERROR] [CONTEXT] public void visitOuterClass( final String owner, final String name, final String desc) { buf.setLength(0); buf.append("cw.visitOuterClass("); appendConstant(owner); buf.append(","); appendConstant(name); buf.append(","); appendConstant(desc); <extra_id_0> text.add(buf.toString()); } [CLASS] ASMifierClassVisitor [METHOD] visitOuterClass [RETURN_TYPE] void String owner String name String desc [VARIABLES] String desc name owner boolean int ACCESS_CLASS ACCESS_FIELD ACCESS_INNER access flags i n version PrintWriter pw |
ByteVector b = attr.write(cw, code, len, maxStack, maxLocals); | [BUG] ByteVector b = attr.write( cw, code, len, len, maxLocals);[NO-ERROR] [CONTEXT] final void put( final ClassWriter cw, final byte[] code, final int len, final int maxStack, final int maxLocals, final ByteVector out) { Attribute attr = this; while(attr != null) { <extra_id_0> out.putShort(cw.newUTF8(attr.type)).putInt(b.length); out.putByteArray(b.data, 0, b.length); attr = attr.next; } } [CLASS] Attribute [METHOD] put [RETURN_TYPE] void ClassWriter cw final byte[] code final int len final int maxStack final int maxLocals ByteVector out [VARIABLES] byte[] code value boolean Attribute attr next String type ClassWriter cw int len maxLocals maxStack ByteVector b out |
Number open = getOpen(series, item); | [BUG] [ERROR] expected:<org.jfree.data.KeyedObjects@312b1dae> but was:<org.jfree.data.KeyedObjects@4ccabbaa> testSerialization [CONTEXT] public double getOpenValue(int series, int item) { double result = Double.NaN; <extra_id_0> if(open != null) { result = open.doubleValue(); } return result; [CLASS] DefaultHighLowDataset [METHOD] getOpenValue [RETURN_TYPE] double int series int item [VARIABLES] Comparable seriesKey Number[] close high low open volume boolean Number open Date[] date double result int item series |
+ string.substring( index | 1); | [BUG] + string.substring(index + 1); [CONTEXT] private String escape(String string) { int index = string.indexOf('\''); while(index != -1) { string = string.substring(0, index) +"'" <extra_id_0> index = string.indexOf('\''); } index = string.indexOf('\"'); while(index != -1) { string = string.substring(0, index) +""" + string.substring(index + 1); index = string.indexOf('\"'); } return string; } [CLASS] DOMNodePointer [METHOD] escape [RETURN_TYPE] String String string [VARIABLES] String XMLNS_NAMESPACE_URI XML_NAMESPACE_URI attr current defaultNamespace id lang ln namespace namespaceURI nodeNS nodePI ns nsURI prefix qname s1 s2 string target testPI testPrefix boolean Map namespaces long serialVersionUID int index Node aNode child n node parent textNode valueNode |
buf.append(')'); returnType.getDescriptor(buf); | [BUG] [NO-ERROR] [CONTEXT] public static String getMethodDescriptor( final Type returnType, final Type[] argumentTypes) { StringBuffer buf = new StringBuffer(); buf.append('('); for(int i = 0; i < argumentTypes.length; ++i) { argumentTypes[i].getDescriptor(buf); } <extra_id_0> return buf.toString(); [CLASS] Type [METHOD] getMethodDescriptor [RETURN_TYPE] String Type returnType Type[] argumentTypes [VARIABLES] Type[] argumentTypes Type BOOLEAN_TYPE BYTE_TYPE CHAR_TYPE DOUBLE_TYPE FLOAT_TYPE INT_TYPE LONG_TYPE SHORT_TYPE VOID_TYPE returnType StringBuffer buf boolean int ARRAY BOOLEAN BYTE CHAR DOUBLE FLOAT INT LONG OBJECT SHORT VOID i len off size sort char[] buf |
if(ianns && ClassReader.ANNOTATIONS != null) { | [BUG] if(ClassReader.ANNOTATIONS && ianns != null){ [CONTEXT] } if((access & Opcodes.ACC_SYNTHETIC) != 0 &&(cw.version & 0xffff) < Opcodes.V1_5) { ++attributeCount; } if((access & Opcodes.ACC_DEPRECATED) != 0) { ++attributeCount; } if(ClassReader.SIGNATURES && signature != 0) { ++attributeCount; } if(ClassReader.ANNOTATIONS && anns != null) { ++attributeCount; } <extra_id_0> ++attributeCount; } if(attrs != null) { attributeCount += attrs.getCount(); } out.putShort(attributeCount); if(value != 0) { out.putShort(cw.newUTF8("ConstantValue")); out.putInt(2).putShort(value); } if((access & Opcodes.ACC_SYNTHETIC) != 0 &&(cw.version & 0xffff) < Opcodes.V1_5) { out.putShort(cw.newUTF8("Synthetic")).putInt(0); } [CLASS] FieldWriter [METHOD] put [RETURN_TYPE] void ByteVector out [VARIABLES] boolean Attribute attr attrs AnnotationWriter anns aw ianns FieldWriter next ClassWriter cw int access attributeCount desc name signature size value ByteVector out |
if(depth >= MAX_DEPTH) { | [BUG] if(depth > MAX_DEPTH){ [CONTEXT] public FlowScope createChildFlowScope() { frozen = true; <extra_id_0> if(flattened == null) { flattened = new FlatFlowScopeCache(this); } return new LinkedFlowScope(flattened); } return new LinkedFlowScope(this); } [CLASS] LinkedFlowScope FlowScopeJoinOp LinkedFlowSlot FlatFlowScopeCache [METHOD] createChildFlowScope [RETURN_TYPE] FlowScope [VARIABLES] LinkedFlowScope directParent joinedScopeA joinedScopeB linkedEquivalent parent LinkedFlowSlot lastSlot parent slot boolean frozen Set dirtySymbols symbolNames Scope functionScope scope Map slotsA slotsB symbols int MAX_DEPTH depth FlatFlowScopeCache cache flattened |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 8