const val BOUNCYCASTLE_PROPERTY = "bouncycastle"
      const val LOOM_PROPERTY = "loom"

      /**
       * For whatever reason our BouncyCastle provider doesn't work with ECDSA keys. Just configure it
       * to use RSA-2048 instead.
       *
       * (We otherwise prefer ECDSA because it's faster.)
       */

      <li><a href="https://maven.apache.org/xsd/maven-4.1.0.xsd">https://maven.apache.org/xsd/maven-4.1.0.xsd</a> for Maven 4.</li>
    </ul>
    ]]>
  </description>
  <defaults>
    <default>
      <key>package</key>
      <value>org.apache.maven.model</value>
    </default>
  </defaults>
  <classes>
    <class rootElement="true" xml.tagName="project">
      <name>Model</name>
      <superClass>ModelBase</superClass>

     * to avoid any nasty memory leak issues that come from keeping Gradle implementation types in memory. Since we
     * use this a the key for our HashMap, it's best to control the implementation as there's no guarantee that Gradle's
     * various {@link TestDescriptor} implementations reliably implement equals and hashCode.
     */

      for (Object o : entries) {
        @SuppressWarnings("unchecked")
        Multiset.Entry<E> entry = (Entry<E>) o;
        checkArgument(
            elements.add(entry.getElement()), "Duplicate keys not allowed in EntrySetGenerator");
        for (int i = 0; i < entry.getCount(); i++) {
          contents.add(entry.getElement());
        }
      }

    }

    @Test
    public void test_getType_immutability() {
        // Test that getType returns the same value consistently
        String type = "ApiKey";
        String message = "API key expired";
        InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        String firstCall = exception.getType();
        String secondCall = exception.getType();

func (f Filter) TestTags(userTags string) bool {
	if f.cachedTags == nil {
		cache := make(map[string]string)
		for _, t := range append(f.And.Tags, f.Tag) {
			if !t.IsEmpty() {
				cache[t.Key] = t.Value
			}
		}
		f.cachedTags = cache
	}

	// This filter does not have any tags, always return true
	if len(f.cachedTags) == 0 {
		return true
	}

    socket: MockWebServerSocket,
    request: RecordedRequest,
    response: MockResponse,
  ) {
    val key = request.headers["Sec-WebSocket-Key"]
    val webSocketResponse =
      response
        .newBuilder()
        .setHeader("Sec-WebSocket-Accept", WebSocketProtocol.acceptHeader(key!!))
        .build()
    writeHttpResponse(socket, webSocketResponse)

  - `--service-account-key-file`, set to one or more files containing one or more public keys used to verify tokens.

        inner.put("key", "value");
        final Map<String, Object> outer = new LinkedHashMap<>();
        outer.put("inner", inner);
        source.put("nested", outer);

        final String json = new JsonIndexExportFormatter().format(source, Collections.emptySet());

        assertTrue(json.contains("\"nested\": {\"inner\": {\"key\": \"value\"}}"));
    }

    @Test

            BuildPlanExecutor.attachToThread(step.project);
            session.setCurrentProject(step.project);
        }

        private Clock getClock(Object key) {
            return clocks.computeIfAbsent(key, p -> new Clock());
        }

        private void plan() {
            lock.writeLock().lock();
            try {
                Set<BuildStep> planSteps = plan.allSteps()