User appliedUser;
        String changePasswordUsername;
        String changePasswordPassword;
        boolean changePasswordResult = false;

        @Override
        public void insert(User user) {
            insertCalled = true;
            insertedUser = user;
        }

        @Override
        public void delete(User user) {
            deleteCalled = true;

      assertThat(actualStats.min()).isWithin(ALLOWED_ERROR).of(expectedStats.min());
      assertThat(actualStats.max()).isWithin(ALLOWED_ERROR).of(expectedStats.max());
    }
  }

  /**
   * Asserts that {@code transformation} is diagonal (i.e. neither horizontal nor vertical) and
   * passes through both {@code (x1, y1)} and {@code (x1 + xDelta, y1 + yDelta)}. Includes

    }

    // ----------------------------------------------------------------------
    // Field validation
    // ----------------------------------------------------------------------

    /**
     * Asserts:
     * <p/>
     * <ul>
     * <li><code>string.length != null</code>
     * <li><code>string.length > 0</code>
     * </ul>
     */
    private static boolean validateStringNotEmpty(

 * case, you should override {@code get()} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingFuture}.
 *
 * <p>Most subclasses can just use {@link SimpleForwardingFuture}.
 *

 * limitations under the License.
 */

package gradlebuild.binarycompatibility

import org.intellij.lang.annotations.Language
import org.junit.Test


/**
 * Asserts Kotlin `internal` members are filtered from the comparison.
 */
class KotlinInternalFilteringTest : AbstractBinaryCompatibilityTest() {

    @Language("kotlin")
    private
    val internalMembers = """

 * provided {@code standardOffer} method.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingDeque}.
 *

 * unexpected behavior. In this case, you should override {@code get()} as well.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingListenableFuture}.
 *
 * <p>Most subclasses can just use {@link SimpleForwardingListenableFuture}.
 *

    deleteFromTableKToV(entry, smearedHash(keys[entry]));
    keys[entry] = newKey;
    insertIntoTableKToV(entry, smearedHash(newKey));

    // insert into insertion order linked list, usually at the end
    setSucceeds(newPredecessor, entry);
    setSucceeds(entry, newSuccessor);
  }

  @CanIgnoreReturnValue
  @Override

     */
    public OptionalEntity<JobLog> getJobLog(final String id) {
        return jobLogBhv.selectByPK(id);
    }

    /**
     * Stores a job log entry in the database.
     * Performs an insert or update operation based on whether the job log already exists.
     *
     * @param jobLog the job log to store
     */
    public void store(final JobLog jobLog) {

        sb.append(dm).append(updatedTime);
        sb.append(dm).append(virtualHosts);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================