* @param request the request to create a key for
     * @throws IOException if an I/O error occurs
     */
    protected abstract void makeKey(Request request) throws IOException;

    /**
     * Reads and returns the key of the next message without consuming it.
     *
     * @return the request key of the next message
     * @throws IOException if an I/O error occurs
     */
    protected abstract Request peekKey() throws IOException;

    checkArgument(
        value.signum() >= 0 && value.bitLength() <= Long.SIZE,
        "value (%s) is outside the range for an unsigned long value",
        value);
    return fromLongBits(value.longValue());
  }

  /**
   * Returns an {@code UnsignedLong} holding the value of the specified {@code String}, parsed as an
   * unsigned {@code long} value.
   *

     */
    void reset();

    /**
     * Gets the exception associated with this response.
     *
     * @return an exception linked to an error
     */
    Exception getException();

    /**
     * Sets an exception for this response.
     *
     * @param e the exception to set
     */
    void exception(Exception e);

    /**

                        "If reporting an issue, report it against the plugin in question, not against maven-core"));
    }

    @Test
    void testMojoExecutor() {
        List<String> msgs = new ArrayList<>();
        msgs.add("*****************************************************************");
        msgs.add("* An aggregator Mojo is already executing in parallel build,    *");

 *       locks---to each of the acquired locks, an edge from the soon-to-be-acquired lock is either
 *       verified or created.
 *   <li>If a new edge needs to be created, the outgoing edges of the acquired locks are traversed
 *       to check for a cycle that reaches the lock to be acquired. If no cycle is detected, a new
 *       "safe" edge is created.
 *   <li>If a cycle is detected, an "unsafe" (cyclic) edge is created to represent a potential

 *   <li>If no exceptions or errors were thrown in the try block, the <i>first</i> exception thrown
 *       by an attempt to close a resource will be thrown.
 *   <li>Any exception caught when attempting to close a resource that is <i>not</i> thrown (because
 *       another exception is already being thrown) is <i>suppressed</i>.
 * </ul>
 *
 * <p>An exception that is suppressed is added to the exception that <i>will</i> be thrown using

     * @throws CIFSException if an error occurs accessing the resource
     */
    long createTime() throws CIFSException;

    /**
     * Create a new file but fail if it already exists. The check for
     * existence of the file and it's creation are an atomic operation with
     * respect to other filesystem activities.
     *
     * @throws CIFSException if an error occurs creating the file
     */

import com.google.errorprone.annotations.DoNotMock;
import java.time.Duration;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * An object with an operational state, plus asynchronous {@link #startAsync()} and {@link
 * #stopAsync()} lifecycle methods to transition between states. Example services include
 * webservers, RPC servers and timers.
 *

   * IllegalArgumentException} if passed a {@code fromKey} less than an earlier {@code fromKey}.
   * However, this method doesn't throw an exception in that situation, but instead keeps the
   * original {@code fromKey}. Similarly, this method keeps the original {@code toKey}, instead of
   * throwing an exception, if passed a {@code toKey} greater than an earlier {@code toKey}.
   */
  @Override

 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */