Set<ApiChange> left = new HashSet<>(acceptedApiChanges);
        left.removeAll(seenApiChanges);
        if (!left.isEmpty()) {
            String formattedLeft = CollectionUtils.join("\n", left);
            throw new RuntimeException("The following regressions are declared as accepted, but didn't match any rule:\n\n" + formattedLeft);
        }
    }

        when {
            isRelease -> "promoteReleaseMilestone"
            else -> "promoteMilestone"
        }

    fun promoteFinalReleaseTaskName(): String =
        when {
            isMaster -> throw UnsupportedOperationException("No final release job on master branch")
            isRelease -> "promoteFinalRelease"
            else -> "promoteFinalBackportRelease"
        }

    requestBodySinks.add(sink)
  }

  override fun isDuplex(): Boolean = true

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink = requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")

  fun assertNoMoreSinks() {
    assertTrue(requestBodySinks.isEmpty())
  }

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

import org.apache.maven.api.annotations.Experimental;

/**
 * The Exception class throw by the {@link Lookup} service.
 *
 * @since 4.0.0
 */
@Experimental
public class LookupException extends MavenException {

    public LookupException(String message) {
        super(message);
    }

        helper.init();
        // destroy() cancels the task and flushes; should not throw
        helper.destroy();
    }

    @Test
    public void test_destroy_beforeInit() {
        LogNotificationHelper helper = new LogNotificationHelper();
        // destroy() without init() should not throw NPE because of null checks
        helper.destroy();
    }

    @Test

  }

  @MapFeature.Require(absent = SUPPORTS_REMOVE)
  public void testRemove_unsupportedNotPresent() {
    try {
      assertNull(
          "remove(notPresent) should return null or throw UnsupportedOperationException",
          getMap().remove(k3()));
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
    expectMissing(e3());
  }

      V oldValue = forwardDelegate.putIfAbsent(e.getKey(), e.getValue());
      if (oldValue != null) {
        throw conflictException("key", e.getKey() + "=" + oldValue, entryArray[i]);
      }
      K oldKey = backwardDelegate.putIfAbsent(e.getValue(), e.getKey());
      if (oldKey != null) {
        throw conflictException("value", oldKey + "=" + e.getValue(), entryArray[i]);
      }
    }

     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getPipe(java.lang.String, int)
     */
    @Override

        if (Objects.requireNonNull(groupId, "groupId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("groupId cannot be empty");
        }
        if (Objects.requireNonNull(artifactId, "artifactId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("artifactId cannot be empty");
        }

        if (model != null) {

    } finally {
      writerClosed = true
    }
  }

  @Throws(IOException::class)
  private fun writeControlFrame(
    opcode: Int,
    payload: ByteString,
  ) {
    if (writerClosed) throw IOException("closed")

    val length = payload.size
    require(length <= PAYLOAD_BYTE_MAX) {
      "Payload size must be less than or equal to $PAYLOAD_BYTE_MAX"
    }

    val b0 = B0_FLAG_FIN or opcode