* See the License for the specific language governing permissions and
 * limitations under the License.
 */

allprojects {
    tasks.withType(JavaCompile).configureEach {
        outputs.doNotCacheIf("CodeQL scanning", { true })
    }

                            </div>
                            <div class="card-body">
                                <div class="form-group row">
                                    <la:info id="msg" message="true">
                                        <div class="alert alert-info">${msg}</div>
                                    </la:info>
                                    <la:errors property="_global"/>

 *
 * <p>For serialization to work, the subclass must specify explicit {@code readObject} and {@code
 * writeObject} methods.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
abstract class AbstractMapBasedMultiset<E extends @Nullable Object> extends AbstractMultiset<E>
    implements Serializable {
  // TODO(lowasser): consider overhauling this back to Map<E, Integer>

import java.util.concurrent.locks.LockSupport;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

@GwtCompatible(emulated = true)
@ReflectionSupport(value = ReflectionSupport.Level.FULL)
@ElementTypesAreNonnullByDefault
// Some Android 5.0.x Samsung devices have bugs in JDK reflection APIs that cause

    extends AbstractImmutableSortedMapMapInterfaceTest<String, Integer> {
  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).headMap("c", true);
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "d";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return 4;
  }

    /*
     * This method is used only by CatchingFuture, and CatchingFuture accepts only Throwable.class
     * under GWT.
     */
    return true;
  }

  static void restoreInterruptIfIsInterruptedException(Throwable t) {}

  private Platform() {}

			Queries("list-type", "2", "metadata", "true")
		// ListObjectsV2
		router.Methods(http.MethodGet).
			HandlerFunc(s3APIMiddleware(api.ListObjectsV2Handler)).
			Queries("list-type", "2")
		// ListObjectVersions
		router.Methods(http.MethodGet).
			HandlerFunc(s3APIMiddleware(api.ListObjectVersionsMHandler)).
			Queries("versions", "", "metadata", "true")
		// ListObjectVersions
		router.Methods(http.MethodGet).

// 1. `POLYMORPHIC` tag
// 2. `POLYMORPHICTYPE` and `POLYMORPHICID` tag
func hasPolymorphicRelation(tagSettings map[string]string) bool {
	if _, ok := tagSettings["POLYMORPHIC"]; ok {
		return true
	}

	_, hasType := tagSettings["POLYMORPHICTYPE"]
	_, hasId := tagSettings["POLYMORPHICID"]

	return hasType && hasId
}

func (schema *Schema) setRelation(relation *Relationship) {

   * wrappers of equal instances should be equal.
   */
  @CanIgnoreReturnValue
  public ForwardingWrapperTester includingEquals() {
    this.testsEquals = true;
    return this;
  }

  /**
   * Tests that the forwarding wrapper returned by {@code wrapperFunction} properly forwards method

/**
 * Unit test for {@link PeekingIterator}.
 *
 * @author Mick Killianey
 */
@SuppressWarnings("serial") // No serialization is used in this test
@GwtCompatible(emulated = true)
@ElementTypesAreNonnullByDefault
public class PeekingIteratorTest extends TestCase {

  /**
   * Version of {@link IteratorTester} that compares an iterator over a given collection of elements