assertEquals(createSet(artifacts), res.getArtifacts(), "Check artifact list");
        assertEquals("1.0", getArtifact("d", res.getArtifacts()).getVersion(), "Check version");
        assertEquals("2.0", getArtifact("b", res.getArtifacts()).getVersion(), "Check version");
    }

    @Test

                        boolean exists = parentCache.hasChild(smbFile.getName());
                        log.debug("Using cached existence check for: {}", smbFile.getPath());
                        return exists;
                    }
                }
            }

            // Fall back to regular existence check
            return smbFile.exists();
        } catch (CIFSException e) {
            throw SmbException.wrap(e);
        }

   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.

   * fact the static type of {@link Throwable} is occasionally justified even for a method with no
   * {@code throws} clause: Some such methods can in fact throw a checked exception (e.g., by
   * calling code written in Kotlin).) Typically, we want to let a {@link Throwable} from such a
   * method propagate untouched, just as we'd typically let it do for a non-reflective call.

 *     <code>1.0alpha1 =&gt; [1, [alpha, 1]]</code></li>
 * <li>Unlimited number of version components,</li>
 * <li>Version components in the text can be digits or strings,</li>
 * <li>Strings are checked for well-known qualifiers, and the qualifier ordering is used for version ordering.
 *     Well-known qualifiers (case-insensitive) are, in order from least to greatest:<ol>
 *     <li><code>alpha</code> or <code>a</code></li>

    @Synchronized get() = total - acknowledged

  @Synchronized
  fun update(
    total: Long = 0,
    acknowledged: Long = 0,
  ) {
    check(total >= 0)
    check(acknowledged >= 0)

    this.total += total
    this.acknowledged += acknowledged

    check(this.acknowledged <= this.total)
  }

  override fun toString(): String =

                                        <div class="form-check">
                                            <la:checkbox styleId="jobLogging" styleClass="form-check-input" property="jobLogging"/>
                                            <label for="jobLogging" class="form-check-label">
                                                <la:message key="labels.enabled"/>

     */
    boolean verifySignature(byte[] buffer, int i, int size);

    /**
     * Checks if signature verification failed.
     *
     * @return whether signature verification failed
     */
    boolean isVerifyFailed();

    /**
     * Checks if the response indicates an error.
     *
     * @return whether the response is an error
     */
    boolean isError();

    /**

  @Throws(IOException::class)
  override fun proceed(request: Request): Response {
    check(index < interceptors.size)

    calls++

    if (exchange != null) {
      check(exchange.finder.routePlanner.sameHostAndPort(request.url)) {
        "network interceptor ${interceptors[index - 1]} must retain the same host and port"
      }
      check(calls == 1) {

        assertEquals(14 + nameBytes.length, bytesEncoded);

        // Check timeout (should be 0)
        assertEquals(0L, SMBUtil.readInt8(buffer, 0));

        // Check name length
        assertEquals(nameBytes.length, SMBUtil.readInt4(buffer, 8));

        // Check timeout specified flag (should be 0)
        assertEquals(0x0, buffer[12]);

        // Check padding
        assertEquals(0x0, buffer[13]);