Resolved merge conflicts and completed merge

java/ql/test/stubs/aspectj/LICENSE.txt

@@ -0,0 +1,279 @@
+Per: https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
+
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.

java/ql/test/stubs/aspectj/org/aspectj/lang/annotation/Pointcut.java

@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License v 2.0
+ * which accompanies this distribution and is available at
+ * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.txt
+ *
+ * Contributors:
+ * initial implementation              Alexandre Vasseur
+ *******************************************************************************/
+package org.aspectj.lang.annotation;
+
+import java.lang.annotation.Target;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Pointcut declaration
+ *
+ * @author Alexandre Vasseur
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface Pointcut {}
+

java/ql/test/stubs/jakarta-persistence-api-3.2.0/jakarta/persistence/EntityManager.java

@@ -0,0 +1,7 @@
+package jakarta.persistence;
+
+public interface EntityManager extends AutoCloseable {
+
+  Query createNativeQuery(String sqlString);
+
+}

java/ql/test/stubs/jakarta-persistence-api-3.2.0/jakarta/persistence/Query.java

@@ -0,0 +1,7 @@
+package jakarta.persistence;
+
+public interface Query {
+
+  int executeUpdate();
+
+}

java/ql/test/stubs/junit-4.13/LICENSE-junit.txt

@@ -0,0 +1,214 @@
+JUnit
+
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+      a) in the case of the initial Contributor, the initial code and
+         documentation distributed under this Agreement, and
+      b) in the case of each subsequent Contributor:
+
+      i) changes to the Program, and
+
+      ii) additions to the Program;
+
+      where such changes and/or additions to the Program originate from and are
+distributed by that particular Contributor. A Contribution 'originates' from a
+Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to
+the Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii) are
+not derivative works of the Program. 
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+      a) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free copyright license to
+reproduce, prepare derivative works of, publicly display, publicly perform,
+distribute and sublicense the Contribution of such Contributor, if any, and
+such derivative works, in source code and object code form.
+
+      b) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free patent license under
+Licensed Patents to make, use, sell, offer to sell, import and otherwise
+transfer the Contribution of such Contributor, if any, in source code and
+object code form. This patent license shall apply to the combination of the
+Contribution and the Program if, at the time the Contribution is added by the
+Contributor, such addition of the Contribution causes such combination to be
+covered by the Licensed Patents. The patent license shall not apply to any
+other combinations which include the Contribution. No hardware per se is
+licensed hereunder. 
+
+      c) Recipient understands that although each Contributor grants the
+licenses to its Contributions set forth herein, no assurances are provided by
+any Contributor that the Program does not infringe the patent or other
+intellectual property rights of any other entity. Each Contributor disclaims
+any liability to Recipient for claims brought by any other entity based on
+infringement of intellectual property rights or otherwise. As a condition to
+exercising the rights and licenses granted hereunder, each Recipient hereby
+assumes sole responsibility to secure any other intellectual property rights
+needed, if any. For example, if a third party patent license is required to
+allow Recipient to distribute the Program, it is Recipient's responsibility to
+acquire that license before distributing the Program.
+
+      d) Each Contributor represents that to its knowledge it has sufficient
+copyright rights in its Contribution, if any, to grant the copyright license
+set forth in this Agreement. 
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under
+its own license agreement, provided that:
+
+      a) it complies with the terms and conditions of this Agreement; and
+
+      b) its license agreement:
+
+      i) effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title
+and non-infringement, and implied warranties or conditions of merchantability
+and fitness for a particular purpose; 
+
+      ii) effectively excludes on behalf of all Contributors all liability for
+damages, including direct, indirect, special, incidental and consequential
+damages, such as lost profits; 
+
+      iii) states that any provisions which differ from this Agreement are
+offered by that Contributor alone and not by any other party; and
+
+      iv) states that source code for the Program is available from such
+Contributor, and informs licensees how to obtain it in a reasonable manner on
+or through a medium customarily used for software exchange. 
+
+When the Program is made available in source code form:
+
+      a) it must be made available under this Agreement; and 
+
+      b) a copy of this Agreement must be included with each copy of the
+Program. 
+
+Contributors may not remove or alter any copyright notices contained within the
+Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if
+any, in a manner that reasonably allows subsequent Recipients to identify the
+originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a manner
+which does not create potential liability for other Contributors. Therefore, if
+a Contributor includes the Program in a commercial product offering, such
+Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+every other Contributor ("Indemnified Contributor") against any losses, damages
+and costs (collectively "Losses") arising from claims, lawsuits and other legal
+actions brought by a third party against the Indemnified Contributor to the
+extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor
+to control, and cooperate with the Commercial Contributor in, the defense and
+any related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If that
+Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such
+Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a court
+requires any other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+Recipient is solely responsible for determining the appropriateness of using
+and distributing the Program and assumes all risks associated with its exercise
+of rights under this Agreement, including but not limited to the risks and
+costs of program errors, compliance with applicable laws, damage to or loss of
+data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable
+law, it shall not affect the validity or enforceability of the remainder of the
+terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such
+provision valid and enforceable.
+
+If Recipient institutes patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software or
+hardware) infringes such Recipient's patent(s), then such Recipient's rights
+granted under Section 2(b) shall terminate as of the date such litigation is
+filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and does
+not cure such failure in a reasonable period of time after becoming aware of
+such noncompliance. If all Recipient's rights under this Agreement terminate,
+Recipient agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall continue
+and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to time.
+No one other than the Agreement Steward has the right to modify this Agreement.
+The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to
+serve as the Agreement Steward to a suitable separate entity. Each new version
+of the Agreement will be given a distinguishing version number. The Program
+(including Contributions) may always be distributed subject to the version of
+the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program
+(including its Contributions) under the new version. Except as expressly stated
+in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether
+expressly, by implication, estoppel or otherwise. All rights in the Program not
+expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial
+in any resulting litigation. 
+

java/ql/test/stubs/junit-4.13/org/junit/Assert.java

@@ -0,0 +1,472 @@
+package org.junit;
+
+import org.junit.function.ThrowingRunnable;
+
+//BSD License
+//
+//Copyright (c) 2000-2006, www.hamcrest.org
+//All rights reserved.
+//
+//Redistribution and use in source and binary forms, with or without
+//modification, are permitted provided that the following conditions are met:
+//
+//Redistributions of source code must retain the above copyright notice, this list of
+//conditions and the following disclaimer. Redistributions in binary form must reproduce
+//the above copyright notice, this list of conditions and the following disclaimer in
+//the documentation and/or other materials provided with the distribution.
+//
+//Neither the name of Hamcrest nor the names of its contributors may be used to endorse
+//or promote products derived from this software without specific prior written
+//permission.
+//
+//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+//EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+//OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+//SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+//TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+//BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+//CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+//WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+//DAMAGE.
+
+/*
+ * MODIFIED version of JUnit 4.13 as available at
+ *   https://search.maven.org/remotecontent?filepath=junit/junit/4.13/junit-4.13-sources.jar
+ * Only parts of this file have been retained for test purposes.
+ */
+
+public class Assert {
+  /**
+   * Asserts that a condition is true. If it isn't it throws an
+   * {@link AssertionError} with the given message.
+   *
+   * @param message   the identifying message for the {@link AssertionError}
+   *                  (<code>null</code>
+   *                  okay)
+   * @param condition condition to be checked
+   */
+  static public void assertTrue(String message, boolean condition) {
+    return;
+  }
+
+  /**
+   * Asserts that a condition is true. If it isn't it throws an
+   * {@link AssertionError} without a message.
+   *
+   * @param condition condition to be checked
+   */
+  static public void assertTrue(boolean condition) {
+    return;
+  }
+
+  /**
+   * Asserts that a condition is false. If it isn't it throws an
+   * {@link AssertionError} with the given message.
+   *
+   * @param message   the identifying message for the {@link AssertionError}
+   *                  (<code>null</code>
+   *                  okay)
+   * @param condition condition to be checked
+   */
+  static public void assertFalse(String message, boolean condition) {
+    return;
+  }
+
+  /**
+   * Asserts that a condition is false. If it isn't it throws an
+   * {@link AssertionError} without a message.
+   *
+   * @param condition condition to be checked
+   */
+  static public void assertFalse(boolean condition) {
+    return;
+  }
+
+  /**
+   * Fails a test with the given message.
+   *
+   * @param message the identifying message for the {@link AssertionError}
+   *                (<code>null</code>
+   *                okay)
+   * @see AssertionError
+   */
+  static public void fail(String message) {
+    if (message == null) {
+      throw new AssertionError();
+    }
+    throw new AssertionError(message);
+  }
+
+  /**
+   * Asserts that an object isn't null. If it is an {@link AssertionError} is
+   * thrown with the given message.
+   *
+   * @param message the identifying message for the {@link AssertionError}
+   *                (<code>null</code>
+   *                okay)
+   * @param object  Object to check or <code>null</code>
+   */
+  static public void assertNotNull(String message, Object object) {
+    return;
+  }
+
+  /**
+   * Asserts that an object isn't null. If it is an {@link AssertionError} is
+   * thrown.
+   *
+   * @param object Object to check or <code>null</code>
+   */
+  static public void assertNotNull(Object object) {
+    return;
+  }
+
+  /**
+   * Asserts that an object is null. If it is not, an {@link AssertionError}
+   * is thrown with the given message.
+   *
+   * @param message the identifying message for the {@link AssertionError}
+   *                (<code>null</code>
+   *                okay)
+   * @param object  Object to check or <code>null</code>
+   */
+  static public void assertNull(String message, Object object) {
+    return;
+  }
+
+  /**
+   * Asserts that an object is null. If it isn't an {@link AssertionError} is
+   * thrown.
+   *
+   * @param object Object to check or <code>null</code>
+   */
+  static public void assertNull(Object object) {
+    return;
+  }
+
+  private static boolean equalsRegardingNull(Object expected, Object actual) {
+    if (expected == null) {
+      return actual == null;
+    }
+
+    return isEquals(expected, actual);
+  }
+
+  private static boolean isEquals(Object expected, Object actual) {
+    return expected.equals(actual);
+  }
+
+  /**
+   * Asserts that two doubles are equal to within a positive delta.
+   * If they are not, an {@link AssertionError} is thrown with the given
+   * message. If the expected value is infinity then the delta value is
+   * ignored. NaNs are considered equal:
+   * <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
+   *
+   * @param message  the identifying message for the {@link AssertionError}
+   *                 (<code>null</code>
+   *                 okay)
+   * @param expected expected value
+   * @param actual   the value to check against <code>expected</code>
+   * @param delta    the maximum delta between <code>expected</code> and
+   *                 <code>actual</code> for which both numbers are still
+   *                 considered equal.
+   */
+  public static void assertEquals(String message, double expected,
+      double actual, double delta) {
+    return;
+  }
+
+  private static void failNotEquals(String message, Object expected,
+      Object actual) {
+    fail(format(message, expected, actual));
+  }
+
+  static String format(String message, Object expected, Object actual) {
+    String formatted = "";
+    if (message != null && !"".equals(message)) {
+      formatted = message + " ";
+    }
+    String expectedString = String.valueOf(expected);
+    String actualString = String.valueOf(actual);
+    if (equalsRegardingNull(expectedString, actualString)) {
+      return formatted + "expected: "
+          + formatClassAndValue(expected, expectedString)
+          + " but was: " + formatClassAndValue(actual, actualString);
+    } else {
+      return formatted + "expected:<" + expectedString + "> but was:<"
+          + actualString + ">";
+    }
+  }
+
+  private static String formatClass(Class<?> value) {
+      String className = value.getCanonicalName();
+      return className == null ? value.getName() : className;
+  }
+
+  private static String formatClassAndValue(Object value, String valueString) {
+    String className = value == null ? "null" : value.getClass().getName();
+    return className + "<" + valueString + ">";
+  }
+
+  /**
+   * Asserts that two floats are equal to within a positive delta.
+   * If they are not, an {@link AssertionError} is thrown with the given
+   * message. If the expected value is infinity then the delta value is
+   * ignored. NaNs are considered equal:
+   * <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
+   *
+   * @param message  the identifying message for the {@link AssertionError}
+   *                 (<code>null</code>
+   *                 okay)
+   * @param expected expected value
+   * @param actual   the value to check against <code>expected</code>
+   * @param delta    the maximum delta between <code>expected</code> and
+   *                 <code>actual</code> for which both numbers are still
+   *                 considered equal.
+   */
+  public static void assertEquals(String message, float expected, float actual,
+      float delta) {
+    if (floatIsDifferent(expected, actual, delta)) {
+      failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
+    }
+  }
+
+  private static boolean doubleIsDifferent(double d1, double d2, double delta) {
+    if (Double.compare(d1, d2) == 0) {
+      return false;
+    }
+    if ((Math.abs(d1 - d2) <= delta)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private static boolean floatIsDifferent(float f1, float f2, float delta) {
+    if (Float.compare(f1, f2) == 0) {
+      return false;
+    }
+    if ((Math.abs(f1 - f2) <= delta)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Asserts that two longs are equal. If they are not, an
+   * {@link AssertionError} is thrown.
+   *
+   * @param expected expected long value.
+   * @param actual   actual long value
+   */
+  public static void assertEquals(long expected, long actual) {
+    assertEquals(null, expected, actual);
+  }
+
+  /**
+   * Asserts that two longs are equal. If they are not, an
+   * {@link AssertionError} is thrown with the given message.
+   *
+   * @param message  the identifying message for the {@link AssertionError}
+   *                 (<code>null</code>
+   *                 okay)
+   * @param expected long expected value.
+   * @param actual   long actual value
+   */
+  public static void assertEquals(String message, long expected, long actual) {
+    if (expected != actual) {
+      failNotEquals(message, Long.valueOf(expected), Long.valueOf(actual));
+    }
+  }
+
+  /**
+   * @deprecated Use
+   *             <code>assertEquals(double expected, double actual, double
+   * delta)</code> instead
+   */
+  @Deprecated
+  public static void assertEquals(double expected, double actual) {
+    assertEquals(null, expected, actual);
+  }
+
+  /**
+   * @deprecated Use
+   *             <code>assertEquals(String message, double expected, double
+   * actual, double delta)</code> instead
+   */
+  @Deprecated
+  public static void assertEquals(String message, double expected,
+      double actual) {
+    fail("Use assertEquals(expected, actual, delta) to compare " +
+        "floating-point numbers");
+  }
+
+  /**
+   * Asserts that two doubles are equal to within a positive delta.
+   * If they are not, an {@link AssertionError} is thrown. If the expected
+   * value is infinity then the delta value is ignored.NaNs are considered
+   * equal: <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
+   *
+   * @param expected expected value
+   * @param actual   the value to check against <code>expected</code>
+   * @param delta    the maximum delta between <code>expected</code> and
+   *                 <code>actual</code> for which both numbers are still
+   *                 considered equal.
+   */
+  public static void assertEquals(double expected, double actual,
+      double delta) {
+    assertEquals(null, expected, actual, delta);
+  }
+
+  /**
+   * Asserts that two floats are equal to within a positive delta.
+   * If they are not, an {@link AssertionError} is thrown. If the expected
+   * value is infinity then the delta value is ignored. NaNs are considered
+   * equal: <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
+   *
+   * @param expected expected value
+   * @param actual   the value to check against <code>expected</code>
+   * @param delta    the maximum delta between <code>expected</code> and
+   *                 <code>actual</code> for which both numbers are still
+   *                 considered equal.
+   */
+  public static void assertEquals(float expected, float actual, float delta) {
+    assertEquals(null, expected, actual, delta);
+  }
+
+  /**
+   * Asserts that two objects are equal. If they are not, an
+   * {@link AssertionError} without a message is thrown. If
+   * <code>expected</code> and <code>actual</code> are <code>null</code>,
+   * they are considered equal.
+   *
+   * @param expected expected value
+   * @param actual   the value to check against <code>expected</code>
+   */
+  public static void assertEquals(Object expected, Object actual) {
+    assertEquals(null, expected, actual);
+  }
+
+  public static void assertEquals(String message, Object expected,
+      Object actual) {
+  }
+
+  public static void assertNotEquals(String message, Object unexpected, Object actual) {
+    return;
+  }
+
+  public static void assertNotEquals(Object unexpected, Object actual) {
+    assertNotEquals(null, unexpected, actual);
+  }
+
+  public static void assertNotEquals(String message, long unexpected, long actual) {
+    return;
+  }
+
+  public static void assertNotEquals(long unexpected, long actual) {
+    assertNotEquals(null, unexpected, actual);
+  }
+
+  public static void assertNotEquals(String message, double unexpected, double actual, double delta) {
+    return;
+  }
+
+  public static void assertNotEquals(double unexpected, double actual, double delta) {
+    assertNotEquals(null, unexpected, actual, delta);
+  }
+
+  public static void assertNotEquals(String message, float unexpected, float actual, float delta) {
+    return;
+  }
+
+  public static void assertNotEquals(float unexpected, float actual, float delta) {
+    assertNotEquals(null, unexpected, actual, delta);
+  }
+
+  public static void assertNotSame(String message, Object unexpected, Object actual) {
+    return;
+  }
+
+  public static void assertNotSame(Object unexpected, Object actual) {
+    assertNotSame(null, unexpected, actual);
+  }
+
+  public static void assertSame(String message, Object expected, Object actual) {
+    return;
+  }
+
+  public static void assertSame(Object expected, Object actual) {
+    assertSame(null, expected, actual);
+  }
+
+  /**
+   * Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
+   * executed. If it does, the exception object is returned. If it does not throw an exception, an
+   * {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
+   * AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
+   * be obtained by calling {@link AssertionError#getCause}.
+   *
+   * @param expectedThrowable the expected type of the exception
+   * @param runnable       a function that is expected to throw an exception when executed
+   * @return the exception thrown by {@code runnable}
+   * @since 4.13
+   */
+  public static <T extends Throwable> T assertThrows(Class<T> expectedThrowable,
+          ThrowingRunnable runnable) {
+      return assertThrows(null, expectedThrowable, runnable);
+  }
+
+  /**
+   * Asserts that {@code runnable} throws an exception of type {@code expectedThrowable} when
+   * executed. If it does, the exception object is returned. If it does not throw an exception, an
+   * {@link AssertionError} is thrown. If it throws the wrong type of exception, an {@code
+   * AssertionError} is thrown describing the mismatch; the exception that was actually thrown can
+   * be obtained by calling {@link AssertionError#getCause}.
+   *
+   * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+   * okay)
+   * @param expectedThrowable the expected type of the exception
+   * @param runnable a function that is expected to throw an exception when executed
+   * @return the exception thrown by {@code runnable}
+   * @since 4.13
+   */
+  public static <T extends Throwable> T assertThrows(String message, Class<T> expectedThrowable,
+          ThrowingRunnable runnable) {
+      try {
+          runnable.run();
+      } catch (Throwable actualThrown) {
+          if (expectedThrowable.isInstance(actualThrown)) {
+              @SuppressWarnings("unchecked") T retVal = (T) actualThrown;
+              return retVal;
+          } else {
+              String expected = formatClass(expectedThrowable);
+              Class<? extends Throwable> actualThrowable = actualThrown.getClass();
+              String actual = formatClass(actualThrowable);
+              if (expected.equals(actual)) {
+                  // There must be multiple class loaders. Add the identity hash code so the message
+                  // doesn't say "expected: java.lang.String<my.package.MyException> ..."
+                  expected += "@" + Integer.toHexString(System.identityHashCode(expectedThrowable));
+                  actual += "@" + Integer.toHexString(System.identityHashCode(actualThrowable));
+              }
+              String mismatchMessage = buildPrefix(message)
+                      + format("unexpected exception type thrown;", expected, actual);
+
+              // The AssertionError(String, Throwable) ctor is only available on JDK7.
+              AssertionError assertionError = new AssertionError(mismatchMessage);
+              assertionError.initCause(actualThrown);
+              throw assertionError;
+          }
+      }
+      String notThrownMessage = buildPrefix(message) + String
+              .format("expected %s to be thrown, but nothing was thrown",
+                      formatClass(expectedThrowable));
+      throw new AssertionError(notThrownMessage);
+  }
+
+  private static String buildPrefix(String message) {
+      return message != null && message.length() != 0 ? message + ": " : "";
+  }
+
+}

java/ql/test/stubs/junit-4.13/org/junit/Test.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2015-2018 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * http://www.eclipse.org/legal/epl-v20.html
+ */
+
+/*
+ * MODIFIED version of junit-jupiter-api 5.2.0 as available at
+ *   https://search.maven.org/classic/remotecontent?filepath=org/junit/jupiter/junit-jupiter-api/5.2.0/junit-jupiter-api-5.2.0-sources.jar
+ * Only parts of this file have been retained for test purposes.
+ */
+
+package org.junit;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface Test {}

java/ql/test/stubs/junit-4.13/org/junit/function/ThrowingRunnable.java

@@ -0,0 +1,14 @@
+package org.junit.function;
+
+/**
+ * This interface facilitates the use of
+ * {@link org.junit.Assert#assertThrows(Class, ThrowingRunnable)} from Java 8. It allows method
+ * references to void methods (that declare checked exceptions) to be passed directly into
+ * {@code assertThrows}
+ * without wrapping. It is not meant to be implemented directly.
+ *
+ * @since 4.13
+ */
+public interface ThrowingRunnable {
+    void run() throws Throwable;
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/api/Nested.java

@@ -0,0 +1,4 @@
+package org.junit.jupiter.api;
+
+public @interface Nested {
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/api/RepeatedTest.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.api;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@TestTemplate
+public @interface RepeatedTest {
+    int value();
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/api/TestFactory.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.api;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface TestFactory {
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/api/TestTemplate.java

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.api;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface TestTemplate {
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/params/ParameterizedTest.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.params;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.junit.jupiter.api.TestTemplate;
+
+@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@TestTemplate
+public @interface ParameterizedTest {
+}

java/ql/test/stubs/junit-jupiter-api-5.2.0/org/junit/jupiter/params/provider/ValueSource.java

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.params.provider;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target({ ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface ValueSource {
+    String[] strings() default {};
+}

java/ql/test/stubs/mockito-5.14/org/mockito/ArgumentMatchers.java

@@ -0,0 +1,4 @@
+package org.mockito;
+
+public class ArgumentMatchers {
+}

java/ql/test/stubs/mockito-5.14/org/mockito/MockSettings.java

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import java.io.Serializable;
+
+public interface MockSettings extends Serializable {
+}

java/ql/test/stubs/mockito-5.14/org/mockito/Mockito.java

@@ -0,0 +1,216 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito;
+
+import org.mockito.ArgumentMatchers;
+import org.mockito.MockSettings;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.stubbing.Answer;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.internal.MockitoCore;
+import org.mockito.MockSettings;
+import org.mockito.stubbing.Stubber;
+
+public class Mockito extends ArgumentMatchers {
+  static final MockitoCore MOCKITO_CORE = new MockitoCore();
+
+  public static MockSettings withSettings() {
+    return new MockSettings() {
+    };
+  }
+
+  /**
+   * Creates a mock object of the requested class or interface.
+   * <p>
+   * See examples in javadoc for the {@link Mockito} class.
+   *
+   * @param reified don't pass any values to it. It's a trick to detect the
+   *                class/interface you
+   *                want to mock.
+   * @return the mock object.
+   * @since 4.10.0
+   */
+  @SafeVarargs
+  public static <T> T mock(T... reified) {
+    return mock(withSettings(), reified);
+  }
+
+  /**
+   * Creates a mock object of the requested class or interface with the given
+   * default answer.
+   * <p>
+   * See examples in javadoc for the {@link Mockito} class.
+   *
+   * @param defaultAnswer the default answer to use.
+   * @param reified       don't pass any values to it. It's a trick to detect the
+   *                      class/interface you
+   *                      want to mock.
+   * @return the mock object.
+   * @since 5.1.0
+   */
+  @SafeVarargs
+  public static <T> T mock(@SuppressWarnings("rawtypes") Answer defaultAnswer, T... reified) {
+    return mock(new Answer<T>() {
+    }, reified);
+  }
+
+  /**
+   * Creates a mock object of the requested class or interface with the given
+   * name.
+   * <p>
+   * See examples in javadoc for the {@link Mockito} class.
+   *
+   * @param name    the mock name to use.
+   * @param reified don't pass any values to it. It's a trick to detect the
+   *                class/interface you
+   *                want to mock.
+   * @return the mock object.
+   * @since 5.1.0
+   */
+  @SafeVarargs
+  public static <T> T mock(String name, T... reified) {
+    return mock(withSettings(), reified);
+  }
+
+  /**
+   * Creates a mock object of the requested class or interface with the given
+   * settings.
+   * <p>
+   * See examples in javadoc for the {@link Mockito} class.
+   *
+   * @param settings the mock settings to use.
+   * @param reified  don't pass any values to it. It's a trick to detect the
+   *                 class/interface you
+   *                 want to mock.
+   * @return the mock object.
+   * @since 5.1.0
+   */
+  @SafeVarargs
+  public static <T> T mock(MockSettings settings, T... reified) {
+    if (reified == null || reified.length > 0) {
+      throw new IllegalArgumentException(
+          "Please don't pass any values here. Java will detect class automagically.");
+    }
+
+    return mock(getClassOf(reified), settings);
+  }
+
+  /**
+   * Creates mock object of given class or interface.
+   * <p>
+   * See examples in javadoc for {@link Mockito} class
+   *
+   * @param classToMock class or interface to mock
+   * @return mock object
+   */
+  public static <T> T mock(Class<T> classToMock) {
+    return mock(classToMock, withSettings());
+  }
+
+  /**
+   * Specifies mock name. Naming mocks can be helpful for debugging - the name is
+   * used in all verification errors.
+   * <p>
+   * Beware that naming mocks is not a solution for complex code which uses too
+   * many mocks or collaborators.
+   * <b>If you have too many mocks then refactor the code</b> so that it's easy to
+   * test/debug without necessity of naming mocks.
+   * <p>
+   * <b>If you use <code>&#064;Mock</code> annotation then you've got naming mocks
+   * for free!</b> <code>&#064;Mock</code> uses field name as mock name.
+   * {@link Mock Read more.}
+   * <p>
+   *
+   * See examples in javadoc for {@link Mockito} class
+   *
+   * @param classToMock class or interface to mock
+   * @param name        of the mock
+   * @return mock object
+   */
+  public static <T> T mock(Class<T> classToMock, String name) {
+    return mock(classToMock, new Answer<T>() {
+    });
+  }
+
+  /**
+   * Creates mock with a specified strategy for its answers to interactions.
+   * It's quite an advanced feature and typically you don't need it to write
+   * decent tests.
+   * However it can be helpful when working with legacy systems.
+   * <p>
+   * It is the default answer so it will be used <b>only when you don't</b> stub
+   * the method call.
+   *
+   * <pre class="code">
+   * <code class="java">
+   *   Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
+   *   Foo mockTwo = mock(Foo.class, new YourOwnAnswer());
+   * </code>
+   * </pre>
+   *
+   * <p>
+   * See examples in javadoc for {@link Mockito} class
+   * </p>
+   *
+   * @param classToMock   class or interface to mock
+   * @param defaultAnswer default answer for un-stubbed methods
+   *
+   * @return mock object
+   */
+  public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
+    return mock(classToMock, new Answer<T>() {
+    });
+  }
+
+  /**
+   * Creates a mock with some non-standard settings.
+   * <p>
+   * The number of configuration points for a mock will grow,
+   * so we need a fluent way to introduce new configuration without adding more
+   * and more overloaded Mockito.mock() methods.
+   * Hence {@link MockSettings}.
+   * 
+   * <pre class="code">
+   * <code class="java">
+   *   Listener mock = mock(Listener.class, withSettings()
+   *     .name("firstListner").defaultBehavior(RETURNS_SMART_NULLS));
+   *   );
+   * </code>
+   * </pre>
+   * 
+   * <b>Use it carefully and occasionally</b>. What might be reason your test
+   * needs non-standard mocks?
+   * Is the code under test so complicated that it requires non-standard mocks?
+   * Wouldn't you prefer to refactor the code under test, so that it is testable
+   * in a simple way?
+   * <p>
+   * See also {@link Mockito#withSettings()}
+   * <p>
+   * See examples in javadoc for {@link Mockito} class
+   *
+   * @param classToMock  class or interface to mock
+   * @param mockSettings additional mock settings
+   * @return mock object
+   */
+  public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
+    return MOCKITO_CORE.mock(classToMock, mockSettings);
+  }
+
+  private static <T> Class<T> getClassOf(T[] array) {
+    return (Class<T>) array.getClass().getComponentType();
+  }
+
+  public static <T> OngoingStubbing<T> when(T methodCall) {
+    return MOCKITO_CORE.when(methodCall);
+  }
+
+  public static Stubber doReturn(Object toBeReturned) {
+    return null;
+  }
+
+  public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext) {
+    return null;
+  }
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/MockitoCore.java

@@ -0,0 +1,28 @@
+package org.mockito.internal;
+
+import org.mockito.MockSettings;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.progress.MockingProgress;
+import org.mockito.stubbing.OngoingStubbing;
+import org.mockito.mock.MockCreationSettings;
+import static org.mockito.internal.util.MockUtil.createMock;
+
+public class MockitoCore {
+  public <T> T mock(Class<T> typeToMock, MockSettings settings) {
+    MockSettingsImpl impl = (MockSettingsImpl) settings;
+    MockCreationSettings<T> creationSettings = impl.build(typeToMock);
+    T mock = createMock(creationSettings);
+    return mock;
+  }
+
+  public <T> OngoingStubbing<T> when(T methodCall) {
+    MockingProgress mockingProgress = new MockingProgress() {
+      @Override
+      public OngoingStubbing<?> pullOngoingStubbing() {
+        return null;
+      }
+    };
+    OngoingStubbing<T> stubbing = (OngoingStubbing<T>) mockingProgress.pullOngoingStubbing();
+    return stubbing;
+  }
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/creation/MockSettingsImpl.java

@@ -0,0 +1,14 @@
+package org.mockito.internal.creation;
+
+import org.mockito.MockSettings;
+import org.mockito.mock.MockCreationSettings;
+
+public class MockSettingsImpl<T> implements MockSettings {
+  public <T2> MockCreationSettings<T2> build(Class<T2> typeToMock) {
+    return new MockCreationSettings<T2>() {
+      public String getMockMaker() {
+        return null;
+      }
+    };
+  }
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/handler/MockHandlerFactory.java

@@ -0,0 +1,14 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.invocation.MockHandler;
+
+public final class MockHandlerFactory {
+    public static <T> MockHandler<T> createMockHandler(MockCreationSettings<T> settings) {
+        return new MockHandlerImpl<T>();
+    }
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/handler/MockHandlerImpl.java

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.handler;
+
+import org.mockito.invocation.MockHandler;
+
+public class MockHandlerImpl<T> implements MockHandler<T> {
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/progress/MockingProgress.java

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.progress;
+
+import org.mockito.stubbing.OngoingStubbing;
+
+public interface MockingProgress {
+  OngoingStubbing<?> pullOngoingStubbing();
+}

java/ql/test/stubs/mockito-5.14/org/mockito/internal/util/MockUtil.java

@@ -0,0 +1,18 @@
+package org.mockito.internal.util;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.plugins.MockMaker;
+import org.mockito.invocation.MockHandler;
+import static org.mockito.internal.handler.MockHandlerFactory.createMockHandler;
+
+public class MockUtil {
+    public static <T> T createMock(MockCreationSettings<T> settings) {
+        MockMaker mockMaker = getMockMaker(settings.getMockMaker());
+        MockHandler mockHandler = createMockHandler(settings);
+        return mockMaker.createMock(settings, mockHandler);
+    }
+
+    public static MockMaker getMockMaker(String mockMaker) {
+        return null;
+    }
+}

java/ql/test/stubs/mockito-5.14/org/mockito/invocation/MockHandler.java

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.invocation;
+
+import java.io.Serializable;
+
+public interface MockHandler<T> extends Serializable {
+}

java/ql/test/stubs/mockito-5.14/org/mockito/mock/MockCreationSettings.java

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.mock;
+
+public interface MockCreationSettings<T> {
+  String getMockMaker();
+}

java/ql/test/stubs/mockito-5.14/org/mockito/plugins/MockMaker.java

@@ -0,0 +1,8 @@
+package org.mockito.plugins;
+
+import org.mockito.mock.MockCreationSettings;
+import org.mockito.invocation.MockHandler;
+
+public interface MockMaker {
+  <T> T createMock(MockCreationSettings<T> settings, MockHandler handler);
+}

java/ql/test/stubs/mockito-5.14/org/mockito/stubbing/Answer.java

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.stubbing;
+
+public interface Answer<T> { }

java/ql/test/stubs/mockito-5.14/org/mockito/stubbing/OngoingStubbing.java

@@ -0,0 +1,9 @@
+/*
+ * Copyright (c) 2007 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.stubbing;
+
+public interface OngoingStubbing<T> {
+  OngoingStubbing<T> thenReturn(T value);
+}

java/ql/test/stubs/mockito-5.14/org/mockito/stubbing/Stubber.java

@@ -0,0 +1,5 @@
+package org.mockito.stubbing;
+
+public interface Stubber {
+  <T> T when(T mock);
+}

java/ql/test/stubs/org.mybatis-3.5.4/org/apache/ibatis/annotations/Delete.java

@@ -0,0 +1,14 @@
+package org.apache.ibatis.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Delete {
+    String[] value();
+}

java/ql/test/stubs/org.mybatis-3.5.4/org/apache/ibatis/annotations/Insert.java

@@ -0,0 +1,14 @@
+package org.apache.ibatis.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Insert {
+    String[] value();
+}

java/ql/test/stubs/org.mybatis-3.5.4/org/apache/ibatis/annotations/Update.java

@@ -0,0 +1,14 @@
+package org.apache.ibatis.annotations;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Update {
+    String[] value();
+}

java/ql/test/stubs/org.mybatis-3.5.4/org/apache/ibatis/jdbc/SqlRunner.java

@@ -0,0 +1,37 @@
+package org.apache.ibatis.jdbc;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+public class SqlRunner {
+
+  public static final int NO_GENERATED_KEY = Integer.MIN_VALUE + 1001;
+
+  private final Connection connection;
+  private boolean useGeneratedKeySupport;
+
+  public SqlRunner(Connection connection) {
+    this.connection = connection;
+  }
+
+  public void setUseGeneratedKeySupport(boolean useGeneratedKeySupport) { }
+  public Map<String, Object> selectOne(String sql, Object... args) throws SQLException { return null; }
+  public List<Map<String, Object>> selectAll(String sql, Object... args) throws SQLException { return null; }
+  public int insert(String sql, Object... args) throws SQLException { return 0; }
+  public int update(String sql, Object... args) throws SQLException { return 0; }
+  public int delete(String sql, Object... args) throws SQLException { return 0; }
+  public void closeConnection() { }
+  private void setParameters(PreparedStatement ps, Object... args) throws SQLException { }
+  private List<Map<String, Object>> getResults(ResultSet rs) throws SQLException { return null; }
+
+}