nus-yam/ex-repair huggingface dataset:
Program: 36796
Project: 36796
Buggy source:
/** 
 * <strong>Denigrated</strong>, replaced by   {@linkplain #getIssuerX500Principal()}. This method returns the   {@code issuer}as an implementation specific Principal object, which should not be relied upon by portable code. <p> Gets the   {@code issuer} (issuer distinguished name) value fromthe certificate. The issuer name identifies the entity that signed (and issued) the certificate. <p>The issuer name field contains an X.500 distinguished name (DN). The ASN.1 definition for this is: <pre> issuer    Name<p> Name ::= CHOICE { RDNSequence } RDNSequence ::= SEQUENCE OF RelativeDistinguishedName RelativeDistinguishedName ::= SET OF AttributeValueAssertion AttributeValueAssertion ::= SEQUENCE { AttributeType, AttributeValue } AttributeType ::= OBJECT IDENTIFIER AttributeValue ::= ANY </pre> The  {@code Name} describes a hierarchical name composed ofattributes, such as country name, and corresponding values, such as US. The type of the  {@code AttributeValue} component is determined bythe  {@code AttributeType}; in general it will be a  {@code directoryString}. A   {@code directoryString} is usuallyone of  {@code PrintableString},  {@code TeletexString} or {@code UniversalString}.
 * @return a Principal whose name is the issuer distinguished name.
 */
public abstract Principal getIssuerDN();

Fixed version (ground truth):
/** 
 * <strong>Denigrated</strong>, replaced by   {@linkplain #getIssuerX500Principal()}. This method returns the   {@code issuer}as an implementation specific Principal object, which should not be relied upon by portable code. <p> Gets the   {@code issuer} (issuer distinguished name) value fromthe certificate. The issuer name identifies the entity that signed (and issued) the certificate. <p>The issuer name field contains an X.500 distinguished name (DN). The ASN.1 definition for this is: <pre> issuer    Name Name ::= CHOICE { RDNSequence } RDNSequence ::= SEQUENCE OF RelativeDistinguishedName RelativeDistinguishedName ::= SET OF AttributeValueAssertion AttributeValueAssertion ::= SEQUENCE { AttributeType, AttributeValue } AttributeType ::= OBJECT IDENTIFIER AttributeValue ::= ANY </pre> The  {@code Name} describes a hierarchical name composed ofattributes, such as country name, and corresponding values, such as US. The type of the  {@code AttributeValue} component is determined bythe  {@code AttributeType}; in general it will be a  {@code directoryString}. A   {@code directoryString} is usuallyone of  {@code PrintableString},  {@code TeletexString} or {@code UniversalString}.
 * @return a Principal whose name is the issuer distinguished name.
 */
public abstract Principal getIssuerDN();
Program: 36797
Project: 36797
Buggy source:
/** 
 * Gets an unmodifiable list of Strings representing the OBJECT IDENTIFIERs of the   {@code ExtKeyUsageSyntax} field of theextended key usage extension, (OID = 2.5.29.37).  It indicates one or more purposes for which the certified public key may be used, in addition to or in place of the basic purposes indicated in the key usage extension field.  The ASN.1 definition for this is: <pre> ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId<p> KeyPurposeId ::= OBJECT IDENTIFIER<p> </pre> Key purposes may be defined by any organization with a need. Object identifiers used to identify key purposes shall be assigned in accordance with IANA or ITU-T Rec. X.660 | ISO/IEC/ITU 9834-1. <p> This method was added to version 1.4 of the Java 2 Platform Standard Edition. In order to maintain backwards compatibility with existing service providers, this method is not  {@code abstract}and it provides a default implementation. Subclasses should override this method with a correct implementation.
 * @return the ExtendedKeyUsage extension of this certificate,as an unmodifiable list of object identifiers represented as Strings. Returns null if this certificate does not contain an ExtendedKeyUsage extension.
 * @throws CertificateParsingException if the extension cannot be decoded
 * @since 1.4
 */
public List<String> getExtendedKeyUsage() throws CertificateParsingException {
  return X509CertImpl.getExtendedKeyUsage(this);
}

Fixed version (ground truth):
/** 
 * Gets an unmodifiable list of Strings representing the OBJECT IDENTIFIERs of the   {@code ExtKeyUsageSyntax} field of theextended key usage extension, (OID = 2.5.29.37).  It indicates one or more purposes for which the certified public key may be used, in addition to or in place of the basic purposes indicated in the key usage extension field.  The ASN.1 definition for this is: <pre> ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId KeyPurposeId ::= OBJECT IDENTIFIER </pre> Key purposes may be defined by any organization with a need. Object identifiers used to identify key purposes shall be assigned in accordance with IANA or ITU-T Rec. X.660 | ISO/IEC/ITU 9834-1. <p> This method was added to version 1.4 of the Java 2 Platform Standard Edition. In order to maintain backwards compatibility with existing service providers, this method is not  {@code abstract}and it provides a default implementation. Subclasses should override this method with a correct implementation.
 * @return the ExtendedKeyUsage extension of this certificate,as an unmodifiable list of object identifiers represented as Strings. Returns null if this certificate does not contain an ExtendedKeyUsage extension.
 * @throws CertificateParsingException if the extension cannot be decoded
 * @since 1.4
 */
public List<String> getExtendedKeyUsage() throws CertificateParsingException {
  return X509CertImpl.getExtendedKeyUsage(this);
}
Program: 36798
Project: 36798
Buggy source:
/** 
 * Gets the   {@code notBefore} date from the validity period ofthe certificate. The relevant ASN.1 definitions are: <pre> validity             Validity<p> Validity ::= SEQUENCE { notBefore      CertificateValidityDate, notAfter       CertificateValidityDate }<p> CertificateValidityDate ::= CHOICE { utcTime        UTCTime, generalTime    GeneralizedTime } </pre>
 * @return the start date of the validity period.
 * @see #checkValidity
 */
public abstract Date getNotBefore();

Fixed version (ground truth):
/** 
 * Gets the   {@code notBefore} date from the validity period ofthe certificate. The relevant ASN.1 definitions are: <pre> validity             Validity Validity ::= SEQUENCE { notBefore      CertificateValidityDate, notAfter       CertificateValidityDate } CertificateValidityDate ::= CHOICE { utcTime        UTCTime, generalTime    GeneralizedTime } </pre>
 * @return the start date of the validity period.
 * @see #checkValidity
 */
public abstract Date getNotBefore();
Program: 36799
Project: 36799
Buggy source:
/** 
 * Gets the signature algorithm name for the certificate signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier<p> AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();

Fixed version (ground truth):
/** 
 * Gets the signature algorithm name for the certificate signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();
Program: 36800
Project: 36800
Buggy source:
/** 
 * Gets the   {@code subjectUniqueID} value from the certificate.<p>The ASN.1 definition for this is: <pre> subjectUniqueID  [2]  IMPLICIT UniqueIdentifier OPTIONAL<p> UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the subject unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getSubjectUniqueID();

Fixed version (ground truth):
/** 
 * Gets the   {@code subjectUniqueID} value from the certificate.<p>The ASN.1 definition for this is: <pre> subjectUniqueID  [2]  IMPLICIT UniqueIdentifier OPTIONAL UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the subject unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getSubjectUniqueID();
Program: 36802
Project: 36802
Buggy source:
/** 
 * Gets the   {@code version} (version number) value from the CRL.The ASN.1 definition for this is: <pre> version    Version OPTIONAL, -- if present, must be v2<p> Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  } -- v3 does not apply to CRLs but appears for consistency -- with definition of Version for certs </pre>
 * @return the version number, i.e. 1 or 2.
 */
public abstract int getVersion();

Fixed version (ground truth):
/** 
 * Gets the   {@code version} (version number) value from the CRL.The ASN.1 definition for this is: <pre> version    Version OPTIONAL, -- if present, must be v2 Version  ::=  INTEGER  {  v1(0), v2(1), v3(2)  } -- v3 does not apply to CRLs but appears for consistency -- with definition of Version for certs </pre>
 * @return the version number, i.e. 1 or 2.
 */
public abstract int getVersion();
Program: 36803
Project: 36803
Buggy source:
/** 
 * Gets the signature algorithm name for the CRL signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier<p> AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();

Fixed version (ground truth):
/** 
 * Gets the signature algorithm name for the CRL signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();
Program: 36804
Project: 36804
Buggy source:
/** 
 * Gets the   {@code version} (version number) value from thecertificate. The ASN.1 definition for this is: <pre> version  [0] EXPLICIT Version DEFAULT v1<p> Version ::=  INTEGER  {  v1(0), v2(1), v3(2)  } </pre>
 * @return the version number, i.e. 1, 2 or 3.
 */
public abstract int getVersion();

Fixed version (ground truth):
/** 
 * Gets the   {@code version} (version number) value from thecertificate. The ASN.1 definition for this is: <pre> version  [0] EXPLICIT Version DEFAULT v1 Version ::=  INTEGER  {  v1(0), v2(1), v3(2)  } </pre>
 * @return the version number, i.e. 1, 2 or 3.
 */
public abstract int getVersion();
Program: 36805
Project: 36805
Buggy source:
/** 
 * Gets the   {@code serialNumber} value from the certificate.The serial number is an integer assigned by the certification authority to each certificate. It must be unique for each certificate issued by a given CA (i.e., the issuer name and serial number identify a unique certificate). The ASN.1 definition for this is: <pre> serialNumber     CertificateSerialNumber<p> CertificateSerialNumber  ::=  INTEGER </pre>
 * @return the serial number.
 */
public abstract BigInteger getSerialNumber();

Fixed version (ground truth):
/** 
 * Gets the   {@code serialNumber} value from the certificate.The serial number is an integer assigned by the certification authority to each certificate. It must be unique for each certificate issued by a given CA (i.e., the issuer name and serial number identify a unique certificate). The ASN.1 definition for this is: <pre> serialNumber     CertificateSerialNumber CertificateSerialNumber  ::=  INTEGER </pre>
 * @return the serial number.
 */
public abstract BigInteger getSerialNumber();
Program: 36806
Project: 36806
Buggy source:
/** 
 * Gets the   {@code issuerUniqueID} value from the certificate.The issuer unique identifier is present in the certificate to handle the possibility of reuse of issuer names over time. RFC 3280 recommends that names not be reused and that conforming certificates not make use of unique identifiers. Applications conforming to that profile should be capable of parsing unique identifiers and making comparisons. <p>The ASN.1 definition for this is: <pre> issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL<p> UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the issuer unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getIssuerUniqueID();

Fixed version (ground truth):
/** 
 * Gets the   {@code issuerUniqueID} value from the certificate.The issuer unique identifier is present in the certificate to handle the possibility of reuse of issuer names over time. RFC 3280 recommends that names not be reused and that conforming certificates not make use of unique identifiers. Applications conforming to that profile should be capable of parsing unique identifiers and making comparisons. <p>The ASN.1 definition for this is: <pre> issuerUniqueID  [1]  IMPLICIT UniqueIdentifier OPTIONAL UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the issuer unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getIssuerUniqueID();
Program: 36807
Project: 36807
Buggy source:
/** 
 * <strong>Denigrated</strong>, replaced by   {@linkplain #getIssuerX500Principal()}. This method returns the   {@code issuer}as an implementation specific Principal object, which should not be relied upon by portable code. <p> Gets the   {@code issuer} (issuer distinguished name) value fromthe certificate. The issuer name identifies the entity that signed (and issued) the certificate. <p>The issuer name field contains an X.500 distinguished name (DN). The ASN.1 definition for this is: <pre> issuer    Name<p> Name ::= CHOICE { RDNSequence } RDNSequence ::= SEQUENCE OF RelativeDistinguishedName RelativeDistinguishedName ::= SET OF AttributeValueAssertion AttributeValueAssertion ::= SEQUENCE { AttributeType, AttributeValue } AttributeType ::= OBJECT IDENTIFIER AttributeValue ::= ANY </pre> The  {@code Name} describes a hierarchical name composed ofattributes, such as country name, and corresponding values, such as US. The type of the  {@code AttributeValue} component is determined bythe  {@code AttributeType}; in general it will be a  {@code directoryString}. A   {@code directoryString} is usuallyone of  {@code PrintableString},  {@code TeletexString} or {@code UniversalString}.
 * @return a Principal whose name is the issuer distinguished name.
 */
public abstract Principal getIssuerDN();

Fixed version (ground truth):
/** 
 * <strong>Denigrated</strong>, replaced by   {@linkplain #getIssuerX500Principal()}. This method returns the   {@code issuer}as an implementation specific Principal object, which should not be relied upon by portable code. <p> Gets the   {@code issuer} (issuer distinguished name) value fromthe certificate. The issuer name identifies the entity that signed (and issued) the certificate. <p>The issuer name field contains an X.500 distinguished name (DN). The ASN.1 definition for this is: <pre> issuer    Name Name ::= CHOICE { RDNSequence } RDNSequence ::= SEQUENCE OF RelativeDistinguishedName RelativeDistinguishedName ::= SET OF AttributeValueAssertion AttributeValueAssertion ::= SEQUENCE { AttributeType, AttributeValue } AttributeType ::= OBJECT IDENTIFIER AttributeValue ::= ANY </pre> The  {@code Name} describes a hierarchical name composed ofattributes, such as country name, and corresponding values, such as US. The type of the  {@code AttributeValue} component is determined bythe  {@code AttributeType}; in general it will be a  {@code directoryString}. A   {@code directoryString} is usuallyone of  {@code PrintableString},  {@code TeletexString} or {@code UniversalString}.
 * @return a Principal whose name is the issuer distinguished name.
 */
public abstract Principal getIssuerDN();
Program: 36808
Project: 36808
Buggy source:
/** 
 * Gets an unmodifiable list of Strings representing the OBJECT IDENTIFIERs of the   {@code ExtKeyUsageSyntax} field of theextended key usage extension, (OID = 2.5.29.37).  It indicates one or more purposes for which the certified public key may be used, in addition to or in place of the basic purposes indicated in the key usage extension field.  The ASN.1 definition for this is: <pre> ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId<p> KeyPurposeId ::= OBJECT IDENTIFIER<p> </pre> Key purposes may be defined by any organization with a need. Object identifiers used to identify key purposes shall be assigned in accordance with IANA or ITU-T Rec. X.660 | ISO/IEC/ITU 9834-1. <p> This method was added to version 1.4 of the Java 2 Platform Standard Edition. In order to maintain backwards compatibility with existing service providers, this method is not  {@code abstract}and it provides a default implementation. Subclasses should override this method with a correct implementation.
 * @return the ExtendedKeyUsage extension of this certificate,as an unmodifiable list of object identifiers represented as Strings. Returns null if this certificate does not contain an ExtendedKeyUsage extension.
 * @throws CertificateParsingException if the extension cannot be decoded
 * @since 1.4
 */
public List<String> getExtendedKeyUsage() throws CertificateParsingException {
  return X509CertImpl.getExtendedKeyUsage(this);
}

Fixed version (ground truth):
/** 
 * Gets an unmodifiable list of Strings representing the OBJECT IDENTIFIERs of the   {@code ExtKeyUsageSyntax} field of theextended key usage extension, (OID = 2.5.29.37).  It indicates one or more purposes for which the certified public key may be used, in addition to or in place of the basic purposes indicated in the key usage extension field.  The ASN.1 definition for this is: <pre> ExtKeyUsageSyntax ::= SEQUENCE SIZE (1..MAX) OF KeyPurposeId KeyPurposeId ::= OBJECT IDENTIFIER </pre> Key purposes may be defined by any organization with a need. Object identifiers used to identify key purposes shall be assigned in accordance with IANA or ITU-T Rec. X.660 | ISO/IEC/ITU 9834-1. <p> This method was added to version 1.4 of the Java 2 Platform Standard Edition. In order to maintain backwards compatibility with existing service providers, this method is not  {@code abstract}and it provides a default implementation. Subclasses should override this method with a correct implementation.
 * @return the ExtendedKeyUsage extension of this certificate,as an unmodifiable list of object identifiers represented as Strings. Returns null if this certificate does not contain an ExtendedKeyUsage extension.
 * @throws CertificateParsingException if the extension cannot be decoded
 * @since 1.4
 */
public List<String> getExtendedKeyUsage() throws CertificateParsingException {
  return X509CertImpl.getExtendedKeyUsage(this);
}
Program: 36809
Project: 36809
Buggy source:
/** 
 * Gets the   {@code notBefore} date from the validity period ofthe certificate. The relevant ASN.1 definitions are: <pre> validity             Validity<p> Validity ::= SEQUENCE { notBefore      CertificateValidityDate, notAfter       CertificateValidityDate }<p> CertificateValidityDate ::= CHOICE { utcTime        UTCTime, generalTime    GeneralizedTime } </pre>
 * @return the start date of the validity period.
 * @see #checkValidity
 */
public abstract Date getNotBefore();

Fixed version (ground truth):
/** 
 * Gets the   {@code notBefore} date from the validity period ofthe certificate. The relevant ASN.1 definitions are: <pre> validity             Validity Validity ::= SEQUENCE { notBefore      CertificateValidityDate, notAfter       CertificateValidityDate } CertificateValidityDate ::= CHOICE { utcTime        UTCTime, generalTime    GeneralizedTime } </pre>
 * @return the start date of the validity period.
 * @see #checkValidity
 */
public abstract Date getNotBefore();
Program: 36810
Project: 36810
Buggy source:
/** 
 * Gets the signature algorithm name for the certificate signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier<p> AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();

Fixed version (ground truth):
/** 
 * Gets the signature algorithm name for the certificate signature algorithm. An example is the string "SHA256withRSA". The ASN.1 definition for this is: <pre> signatureAlgorithm   AlgorithmIdentifier AlgorithmIdentifier  ::=  SEQUENCE  { algorithm               OBJECT IDENTIFIER, parameters              ANY DEFINED BY algorithm OPTIONAL  } -- contains a value of the type -- registered for use with the -- algorithm object identifier value </pre> <p>The algorithm name is determined from the   {@code algorithm}OID string.
 * @return the signature algorithm name.
 */
public abstract String getSigAlgName();
Program: 36811
Project: 36811
Buggy source:
/** 
 * Gets the   {@code subjectUniqueID} value from the certificate.<p>The ASN.1 definition for this is: <pre> subjectUniqueID  [2]  IMPLICIT UniqueIdentifier OPTIONAL<p> UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the subject unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getSubjectUniqueID();

Fixed version (ground truth):
/** 
 * Gets the   {@code subjectUniqueID} value from the certificate.<p>The ASN.1 definition for this is: <pre> subjectUniqueID  [2]  IMPLICIT UniqueIdentifier OPTIONAL UniqueIdentifier  ::=  BIT STRING </pre>
 * @return the subject unique identifier or null if it is notpresent in the certificate.
 */
public abstract boolean[] getSubjectUniqueID();
Program: 36814
Project: 36814
Buggy source:
/** 
 * Determines whether a class is modifiable by  {@linkplain #retransformClasses retransformation}or   {@linkplain #redefineClasses redefinition}. If a class is modifiable then this method returns <code>true</code>. If a class is not modifiable then this method returns <code>false</code>. <P> For a class to be retransformed,   {@link #isRetransformClassesSupported} must also be true.But the value of <code>isRetransformClassesSupported()</code> does not influence the value returned by this function. For a class to be redefined,  {@link #isRedefineClassesSupported} must also be true.But the value of <code>isRedefineClassesSupported()</code> does not influence the value returned by this function. <P> Primitive classes (for example, <code>java.lang.Integer.TYPE</code>) and array classes are never modifiable.
 * @throws java.lang.NullPointerException if the specified class is <code>null</code>.
 * @see #retransformClasses
 * @see #isRetransformClassesSupported
 * @see #redefineClasses
 * @see #isRedefineClassesSupported
 * @since 1.6
 */
boolean isModifiableClass(Class<?> theClass);

Fixed version (ground truth):
/** 
 * Determines whether a class is modifiable by  {@linkplain #retransformClasses retransformation}or   {@linkplain #redefineClasses redefinition}. If a class is modifiable then this method returns <code>true</code>. If a class is not modifiable then this method returns <code>false</code>. <P> For a class to be retransformed,   {@link #isRetransformClassesSupported} must also be true.But the value of <code>isRetransformClassesSupported()</code> does not influence the value returned by this function. For a class to be redefined,  {@link #isRedefineClassesSupported} must also be true.But the value of <code>isRedefineClassesSupported()</code> does not influence the value returned by this function. <P> Primitive classes (for example, <code>java.lang.Integer.TYPE</code>) and array classes are never modifiable.
 * @param theClass the class to check for being modifiable
 * @return whether or not the argument class is modifiable
 * @throws java.lang.NullPointerException if the specified class is <code>null</code>.
 * @see #retransformClasses
 * @see #isRetransformClassesSupported
 * @see #redefineClasses
 * @see #isRedefineClassesSupported
 * @since 1.6
 */
boolean isModifiableClass(Class<?> theClass);
Program: 36815
Project: 36815
Buggy source:
/** 
 * A query that provides access to whether a leap-second was parsed. <p> This returns a singleton   {@linkplain TemporalQuery query} that providesaccess to additional information from the parse. The query always returns a non-null boolean, true if parsing saw a leap-second, false if not. <p> Instant parsing handles the special "leap second" time of '23:59:60'. Leap seconds occur at '23:59:60' in the UTC time-zone, but at other local times in different time-zones. To avoid this potential ambiguity, the handling of leap-seconds is limited to {@link DateTimeFormatterBuilder#appendInstant()}, as that method always parses the instant with the UTC zone offset. <p> If the time '23:59:60' is received, then a simple conversion is applied, replacing the second-of-minute of 60 with 59. This query can be used on the parse result to determine if the leap-second adjustment was made. The query will return one second of excess if it did adjust to remove the leap-second, and zero if not. Note that applying a leap-second smoothing mechanism, such as UTC-SLS, is the responsibility of the application, as follows: <pre> TemporalAccessor parsed = formatter.parse(str); Instant instant = parsed.query(Instant::from); if (parsed.query(DateTimeFormatter.parsedLeapSecond())) { // validate leap-second is correct and apply correct smoothing } </pre>
 */
public static final TemporalQuery<Boolean> parsedLeapSecond(){
  return PARSED_LEAP_SECOND;
}

Fixed version (ground truth):
/** 
 * A query that provides access to whether a leap-second was parsed. <p> This returns a singleton   {@linkplain TemporalQuery query} that providesaccess to additional information from the parse. The query always returns a non-null boolean, true if parsing saw a leap-second, false if not. <p> Instant parsing handles the special "leap second" time of '23:59:60'. Leap seconds occur at '23:59:60' in the UTC time-zone, but at other local times in different time-zones. To avoid this potential ambiguity, the handling of leap-seconds is limited to {@link DateTimeFormatterBuilder#appendInstant()}, as that method always parses the instant with the UTC zone offset. <p> If the time '23:59:60' is received, then a simple conversion is applied, replacing the second-of-minute of 60 with 59. This query can be used on the parse result to determine if the leap-second adjustment was made. The query will return one second of excess if it did adjust to remove the leap-second, and zero if not. Note that applying a leap-second smoothing mechanism, such as UTC-SLS, is the responsibility of the application, as follows: <pre> TemporalAccessor parsed = formatter.parse(str); Instant instant = parsed.query(Instant::from); if (parsed.query(DateTimeFormatter.parsedLeapSecond())) { // validate leap-second is correct and apply correct smoothing } </pre>
 * @return a query that provides access to whether a leap-second was parsed
 */
public static final TemporalQuery<Boolean> parsedLeapSecond(){
  return PARSED_LEAP_SECOND;
}
Program: 36819
Project: 36819
Buggy source:
/** 
 * Determines whether a class is modifiable by  {@linkplain #retransformClasses retransformation}or   {@linkplain #redefineClasses redefinition}. If a class is modifiable then this method returns <code>true</code>. If a class is not modifiable then this method returns <code>false</code>. <P> For a class to be retransformed,   {@link #isRetransformClassesSupported} must also be true.But the value of <code>isRetransformClassesSupported()</code> does not influence the value returned by this function. For a class to be redefined,  {@link #isRedefineClassesSupported} must also be true.But the value of <code>isRedefineClassesSupported()</code> does not influence the value returned by this function. <P> Primitive classes (for example, <code>java.lang.Integer.TYPE</code>) and array classes are never modifiable.
 * @throws java.lang.NullPointerException if the specified class is <code>null</code>.
 * @see #retransformClasses
 * @see #isRetransformClassesSupported
 * @see #redefineClasses
 * @see #isRedefineClassesSupported
 * @since 1.6
 */
boolean isModifiableClass(Class<?> theClass);

Fixed version (ground truth):
/** 
 * Determines whether a class is modifiable by  {@linkplain #retransformClasses retransformation}or   {@linkplain #redefineClasses redefinition}. If a class is modifiable then this method returns <code>true</code>. If a class is not modifiable then this method returns <code>false</code>. <P> For a class to be retransformed,   {@link #isRetransformClassesSupported} must also be true.But the value of <code>isRetransformClassesSupported()</code> does not influence the value returned by this function. For a class to be redefined,  {@link #isRedefineClassesSupported} must also be true.But the value of <code>isRedefineClassesSupported()</code> does not influence the value returned by this function. <P> Primitive classes (for example, <code>java.lang.Integer.TYPE</code>) and array classes are never modifiable.
 * @param theClass the class to check for being modifiable
 * @return whether or not the argument class is modifiable
 * @throws java.lang.NullPointerException if the specified class is <code>null</code>.
 * @see #retransformClasses
 * @see #isRetransformClassesSupported
 * @see #redefineClasses
 * @see #isRedefineClassesSupported
 * @since 1.6
 */
boolean isModifiableClass(Class<?> theClass);
Program: 36820
Project: 36820
Buggy source:
/** 
 * A query that provides access to whether a leap-second was parsed. <p> This returns a singleton   {@linkplain TemporalQuery query} that providesaccess to additional information from the parse. The query always returns a non-null boolean, true if parsing saw a leap-second, false if not. <p> Instant parsing handles the special "leap second" time of '23:59:60'. Leap seconds occur at '23:59:60' in the UTC time-zone, but at other local times in different time-zones. To avoid this potential ambiguity, the handling of leap-seconds is limited to {@link DateTimeFormatterBuilder#appendInstant()}, as that method always parses the instant with the UTC zone offset. <p> If the time '23:59:60' is received, then a simple conversion is applied, replacing the second-of-minute of 60 with 59. This query can be used on the parse result to determine if the leap-second adjustment was made. The query will return one second of excess if it did adjust to remove the leap-second, and zero if not. Note that applying a leap-second smoothing mechanism, such as UTC-SLS, is the responsibility of the application, as follows: <pre> TemporalAccessor parsed = formatter.parse(str); Instant instant = parsed.query(Instant::from); if (parsed.query(DateTimeFormatter.parsedLeapSecond())) { // validate leap-second is correct and apply correct smoothing } </pre>
 */
public static final TemporalQuery<Boolean> parsedLeapSecond(){
  return PARSED_LEAP_SECOND;
}

Fixed version (ground truth):
/** 
 * A query that provides access to whether a leap-second was parsed. <p> This returns a singleton   {@linkplain TemporalQuery query} that providesaccess to additional information from the parse. The query always returns a non-null boolean, true if parsing saw a leap-second, false if not. <p> Instant parsing handles the special "leap second" time of '23:59:60'. Leap seconds occur at '23:59:60' in the UTC time-zone, but at other local times in different time-zones. To avoid this potential ambiguity, the handling of leap-seconds is limited to {@link DateTimeFormatterBuilder#appendInstant()}, as that method always parses the instant with the UTC zone offset. <p> If the time '23:59:60' is received, then a simple conversion is applied, replacing the second-of-minute of 60 with 59. This query can be used on the parse result to determine if the leap-second adjustment was made. The query will return one second of excess if it did adjust to remove the leap-second, and zero if not. Note that applying a leap-second smoothing mechanism, such as UTC-SLS, is the responsibility of the application, as follows: <pre> TemporalAccessor parsed = formatter.parse(str); Instant instant = parsed.query(Instant::from); if (parsed.query(DateTimeFormatter.parsedLeapSecond())) { // validate leap-second is correct and apply correct smoothing } </pre>
 * @return a query that provides access to whether a leap-second was parsed
 */
public static final TemporalQuery<Boolean> parsedLeapSecond(){
  return PARSED_LEAP_SECOND;
}
Program: 36822
Project: 36822
Buggy source:
/** 
 * Returns a   {@link BinaryOperator} which returns the greater of two elementsaccording to the specified  {@code Comparator}
 * @param comparator a {@code Comparator} for comparing the two values
 * @return a {@code BinaryOperator} which returns the greater of its operands,according to the supplied  {@code Comparator}
 * @throws NullPointerException if the argument is null
 */
public static <T>BinaryOperator<T> maxBy(Comparator<? super T> comparator){
  Objects.requireNonNull(comparator);
  return (a,b) -> comparator.compare(a,b) >= 0 ? a : b;
}

Fixed version (ground truth):
/** 
 * Returns a   {@link BinaryOperator} which returns the greater of two elementsaccording to the specified  {@code Comparator}
 * @param < T > the type of values to be compared and returned
 * @param comparator a {@code Comparator} for comparing the two values
 * @return a {@code BinaryOperator} which returns the greater of its operands,according to the supplied  {@code Comparator}
 * @throws NullPointerException if the argument is null
 */
public static <T>BinaryOperator<T> maxBy(Comparator<? super T> comparator){
  Objects.requireNonNull(comparator);
  return (a,b) -> comparator.compare(a,b) >= 0 ? a : b;
}
Program: 36823
Project: 36823
Buggy source:
/** 
 * Returns a   {@link BinaryOperator} which returns the lesser of two elementsaccording to the specified  {@code Comparator}
 * @param comparator a {@code Comparator} for comparing the two values
 * @return a {@code BinaryOperator} which returns the lesser of its operands,according to the supplied  {@code Comparator}
 * @throws NullPointerException if the argument is null
 */
public static <T>BinaryOperator<T> minBy(Comparator<? super T> comparator){
  Objects.requireNonNull(comparator);
  return (a,b) -> comparator.compare(a,b) <= 0 ? a : b;
}

Fixed version (ground truth):
/** 
 * Returns a   {@link BinaryOperator} which returns the lesser of two elementsaccording to the specified  {@code Comparator}
 * @param < T > the type of values to be compared and returned
 * @param comparator a {@code Comparator} for comparing the two values
 * @return a {@code BinaryOperator} which returns the lesser of its operands,according to the supplied  {@code Comparator}
 * @throws NullPointerException if the argument is null
 */
public static <T>BinaryOperator<T> minBy(Comparator<? super T> comparator){
  Objects.requireNonNull(comparator);
  return (a,b) -> comparator.compare(a,b) <= 0 ? a : b;
}
Program: 36824
Project: 36824
Buggy source:
/** 
 * Returns a   {@code Function} whose {@code apply} method returns its input.
 * @param < T > the type of the input and output objects to the function
 */
static <T>Function<T,T> identity(){
  return t -> t;
}

Fixed version (ground truth):
/** 
 * Returns a   {@code Function} whose {@code apply} method returns its input.
 * @param < T > the type of the input and output objects to the function
 * @return a {@code Function} whose {@code apply} method returns its input
 */
static <T>Function<T,T> identity(){
  return t -> t;
}
Program: 36825
Project: 36825
Buggy source:
/** 
 * Returns a unary operator that provides its input value as the result.
 * @return a unary operator that provides its input value as the result
 */
static <T>UnaryOperator<T> identity(){
  return t -> t;
}

Fixed version (ground truth):
/** 
 * Returns a unary operator that provides its input value as the result.
 * @param < T > the type of the input and output objects to the function
 * @return a unary operator that provides its input value as the result
 */
static <T>UnaryOperator<T> identity(){
  return t -> t;
}
Program: 36826
Project: 36826
Buggy source:
/** 
 * From a given bean, obtain an object representing a specified type view of that source object. <p> The result may be the same object or a different object.  If the requested target view isn't available then the given bean is returned. <p> This method is provided in Beans 1.0 as a hook to allow the addition of more flexible bean behaviour in the future.
 * @param bean        Object from which we want to obtain a view.
 * @param targetType  The type of view we'd like to get.
 */
public static Object getInstanceOf(Object bean,Class<?> targetType){
  return bean;
}

Fixed version (ground truth):
/** 
 * From a given bean, obtain an object representing a specified type view of that source object. <p> The result may be the same object or a different object.  If the requested target view isn't available then the given bean is returned. <p> This method is provided in Beans 1.0 as a hook to allow the addition of more flexible bean behaviour in the future.
 * @return an object representing a specified type view of thesource object
 * @param bean        Object from which we want to obtain a view.
 * @param targetType  The type of view we'd like to get.
 */
public static Object getInstanceOf(Object bean,Class<?> targetType){
  return bean;
}
Program: 36830
Project: 36830
Buggy source:
/** 
 * If the value property of this instance is not already set, this method dynamically finds the method with the specified methodName on this target with these arguments and calls it. The result of the method invocation is first copied into the value property of this expression and then returned as the result of <code>getValue</code>. If the value property was already set, either by a call to <code>setValue</code> or a previous call to <code>getValue</code> then the value property is returned without either looking up or calling the method. <p> The value property of an <code>Expression</code> is set to a unique private (non-<code>null</code>) value by default and this value is used as an internal indication that the method has not yet been called. A return value of <code>null</code> replaces this default value in the same way that any other value would, ensuring that expressions are never evaluated more than once. <p> See the <code>excecute</code> method for details on how methods are chosen using the dynamic types of the target and arguments.
 * @see Statement#execute
 * @see #setValue
 * @return The result of applying this method to these arguments.
 */
public Object getValue() throws Exception {
  if (value == unbound) {
    setValue(invoke());
  }
  return value;
}

Fixed version (ground truth):
/** 
 * If the value property of this instance is not already set, this method dynamically finds the method with the specified methodName on this target with these arguments and calls it. The result of the method invocation is first copied into the value property of this expression and then returned as the result of <code>getValue</code>. If the value property was already set, either by a call to <code>setValue</code> or a previous call to <code>getValue</code> then the value property is returned without either looking up or calling the method. <p> The value property of an <code>Expression</code> is set to a unique private (non-<code>null</code>) value by default and this value is used as an internal indication that the method has not yet been called. A return value of <code>null</code> replaces this default value in the same way that any other value would, ensuring that expressions are never evaluated more than once. <p> See the <code>execute</code> method for details on how methods are chosen using the dynamic types of the target and arguments.
 * @see Statement#execute
 * @see #setValue
 * @return The result of applying this method to these arguments.
 * @throws Exception if the method with the specified methodNamethrows an exception
 */
public Object getValue() throws Exception {
  if (value == unbound) {
    setValue(invoke());
  }
  return value;
}
Program: 36831
Project: 36831
Buggy source:
/** 
 * Sets the method that should be used to read an indexed property value.
 * @param readMethod The new indexed read method.
 */
public synchronized void setIndexedReadMethod(Method readMethod) throws IntrospectionException {
  setIndexedPropertyType(findIndexedPropertyType(readMethod,getIndexedWriteMethod0()));
  setIndexedReadMethod0(readMethod);
}

Fixed version (ground truth):
/** 
 * Sets the method that should be used to read an indexed property value.
 * @param readMethod The new indexed read method.
 * @throws IntrospectionException if an exception occurs duringintrospection.
 */
public synchronized void setIndexedReadMethod(Method readMethod) throws IntrospectionException {
  setIndexedPropertyType(findIndexedPropertyType(readMethod,getIndexedWriteMethod0()));
  setIndexedReadMethod0(readMethod);
}
Program: 36832
Project: 36832
Buggy source:
/** 
 * Sets the method that should be used to write an indexed property value.
 * @param writeMethod The new indexed write method.
 */
public synchronized void setIndexedWriteMethod(Method writeMethod) throws IntrospectionException {
  Class<?> type=findIndexedPropertyType(getIndexedReadMethod(),writeMethod);
  setIndexedPropertyType(type);
  setIndexedWriteMethod0(writeMethod);
}

Fixed version (ground truth):
/** 
 * Sets the method that should be used to write an indexed property value.
 * @param writeMethod The new indexed write method.
 * @throws IntrospectionException if an exception occurs duringintrospection.
 */
public synchronized void setIndexedWriteMethod(Method writeMethod) throws IntrospectionException {
  Class<?> type=findIndexedPropertyType(getIndexedReadMethod(),writeMethod);
  setIndexedPropertyType(type);
  setIndexedWriteMethod0(writeMethod);
}
Program: 36833
Project: 36833
Buggy source:
/** 
 * Sets the method that should be used to write the property value.
 * @param writeMethod The new write method.
 */
public synchronized void setWriteMethod(Method writeMethod) throws IntrospectionException {
  if (writeMethod == null) {
    writeMethodName=null;
    writeMethodRef=null;
    return;
  }
  setPropertyType(findPropertyType(getReadMethod(),writeMethod));
  setClass0(writeMethod.getDeclaringClass());
  writeMethodName=writeMethod.getName();
  this.writeMethodRef=getSoftReference(writeMethod);
  setTransient(writeMethod.getAnnotation(Transient.class));
}

Fixed version (ground truth):
/** 
 * Sets the method that should be used to write the property value.
 * @param writeMethod The new write method.
 * @throws IntrospectionException if the write method is invalid
 */
public synchronized void setWriteMethod(Method writeMethod) throws IntrospectionException {
  if (writeMethod == null) {
    writeMethodName=null;
    writeMethodRef=null;
    return;
  }
  setPropertyType(findPropertyType(getReadMethod(),writeMethod));
  setClass0(writeMethod.getDeclaringClass());
  writeMethodName=writeMethod.getName();
  this.writeMethodRef=getSoftReference(writeMethod);
  setTransient(writeMethod.getAnnotation(Transient.class));
}
Program: 36834
Project: 36834
Buggy source:
/** 
 * Sets the method that should be used to read the property value.
 * @param readMethod The new read method.
 */
public synchronized void setReadMethod(Method readMethod) throws IntrospectionException {
  if (readMethod == null) {
    readMethodName=null;
    readMethodRef=null;
    return;
  }
  setPropertyType(findPropertyType(readMethod,getWriteMethod0()));
  setClass0(readMethod.getDeclaringClass());
  readMethodName=readMethod.getName();
  this.readMethodRef=getSoftReference(readMethod);
  setTransient(readMethod.getAnnotation(Transient.class));
}

Fixed version (ground truth):
/** 
 * Sets the method that should be used to read the property value.
 * @param readMethod The new read method.
 * @throws IntrospectionException if the read method is invalid
 */
public synchronized void setReadMethod(Method readMethod) throws IntrospectionException {
  if (readMethod == null) {
    readMethodName=null;
    readMethodRef=null;
    return;
  }
  setPropertyType(findPropertyType(readMethod,getWriteMethod0()));
  setClass0(readMethod.getDeclaringClass());
  readMethodName=readMethod.getName();
  this.readMethodRef=getSoftReference(readMethod);
  setTransient(readMethod.getAnnotation(Transient.class));
}
Program: 36835
Project: 36835
Buggy source:
/** 
 * Analagous to <code>java.lang.ClassLoader.getResource()</code>, this method allows a <code>BeanContext</code> implementation to interpose behavior between the child <code>Component</code> and underlying <code>ClassLoader</code>.
 * @param name the resource name
 * @param bcc the specified child
 * @return a <code>URL</code> for the namedresource for the specified child
 * @throws <code>IllegalArgumentException</code>if the resource is not valid
 */
URL getResource(String name,BeanContextChild bcc) throws IllegalArgumentException ;

Fixed version (ground truth):
/** 
 * Analagous to <code>java.lang.ClassLoader.getResource()</code>, this method allows a <code>BeanContext</code> implementation to interpose behavior between the child <code>Component</code> and underlying <code>ClassLoader</code>.
 * @param name the resource name
 * @param bcc the specified child
 * @return a <code>URL</code> for the namedresource for the specified child
 * @throws IllegalArgumentException if the resource is not valid
 */
URL getResource(String name,BeanContextChild bcc) throws IllegalArgumentException ;
Program: 36836
Project: 36836
Buggy source:
/** 
 * Adds the specified <code>BeanContextMembershipListener</code> to receive <code>BeanContextMembershipEvents</code> from this <code>BeanContext</code> whenever it adds or removes a child <code>Component</code>(s).
 * @param bcml the <code>BeanContextMembershipListener</code> to be added
 */
void addBeanContextMembershipListener(BeanContextMembershipListener bcml);

Fixed version (ground truth):
/** 
 * Adds the specified <code>BeanContextMembershipListener</code> to receive <code>BeanContextMembershipEvents</code> from this <code>BeanContext</code> whenever it adds or removes a child <code>Component</code>(s).
 * @param bcml the BeanContextMembershipListener to be added
 */
void addBeanContextMembershipListener(BeanContextMembershipListener bcml);