if (errorCode != 0 || andxCommand == (byte) 0xFF) {
            andxCommand = (byte) 0xFF;
            andx = null;
        } else if (andx == null) {
            andxCommand = (byte) 0xFF;
            throw new RuntimeException("no andx command supplied with response");
        } else {

            /*
             * Set bufferIndex according to andxOffset
             */

    if (taskQueue.activeTask == null) {
      if (taskQueue.futureTasks.isNotEmpty()) {
        readyQueues.addIfAbsent(taskQueue)
      } else {
        readyQueues.remove(taskQueue)
      }
    }

    if (coordinatorWaiting) {
      backend.coordinatorNotify(this@TaskRunner)
    } else {
      startAnotherThread()
    }
  }

  private fun beforeRun(task: Task) {
    assertLockHeld()

                            result = 1;
                        }
                    } else {
                        if (a.getClassifier() != null) {
                            result = classifier.compareTo(a.getClassifier());
                        } else {
                            result = -1;
                        }
                    }
                    if (result == 0) {

      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
    responseBody.close()
    assertEquals(if (connectionType == H2) 1 else 0, client.connectionPool.connectionCount())
  }

  @ParameterizedTest
  @ArgumentsSource(CancelModelParamProvider::class)
  fun cancelAndFollowup(mode: Pair<CancelMode, ConnectionType>) {
    setUp(mode)

        this.tree = tree.acquire();
        this.tree_num = tree.getTreeId();

        if (cfg.isTraceResourceUsage()) {
            this.creationBacktrace = Thread.currentThread().getStackTrace();
        } else {
            this.creationBacktrace = null;
        }
    }

    /**
     * @param cfg
     * @param fid
     * @param tree
     * @param unc
     * @param options
     * @param attrs

            this.artifact = ArtifactUtils.copyArtifact(artifact);
            if ("pom".equals(artifact.getType()) && file != null) {
                pomHash = file.getPath().hashCode() + file.lastModified();
            } else {
                pomHash = 0;
            }
            this.resolveManagedVersions = resolveManagedVersions;
            this.repositories.add(localRepository);
            this.repositories.addAll(remoteRepositories);

while [ -h "$SCRIPT" ] ; do
  ls=`ls -ld "$SCRIPT"`
  # Drop everything prior to ->
  link=`expr "$ls" : '.*-> \(.*\)$'`
  if expr "$link" : '/.*' > /dev/null; then
    SCRIPT="$link"
  else
    SCRIPT=`dirname "$SCRIPT"`/"$link"
  fi
done

# determine fess home
FESS_HOME=`dirname "$SCRIPT"`/..

# make FESS_HOME absolute
FESS_HOME=`cd "$FESS_HOME"; pwd`

			errs = append(errs, fmt.Errorf("Unable to apply heal config: %w", err))
		} else {
			globalHealConfig.Update(healCfg)
		}
	case config.BatchSubSys:
		batchCfg, err := batch.LookupConfig(s[config.BatchSubSys][config.Default])
		if err != nil {
			errs = append(errs, fmt.Errorf("Unable to apply batch config: %w", err))
		} else {
			globalBatchConfig.Update(batchCfg)
		}
	case config.ScannerSubSys:

        else -> append(addressHostname)
      }
      if (address.url.port != socketAddress.port || addressHostname == socketHostname) {
        append(":")
        append(address.url.port)
      }

      if (addressHostname != socketHostname) {
        when (proxy) {
          Proxy.NO_PROXY -> append(" at ")
          else -> append(" via proxy ")
        }

		if err != nil {
			return
		}
	} else {
		err = z.XferRateLrg.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "XferRateLrg")
			return
		}
	}
	// write "st"
	err = en.Append(0xa2, 0x73, 0x74)
	if err != nil {
		return
	}
	if z.XferRateSml == nil {
		err = en.WriteNil()
		if err != nil {
			return
		}
	} else {
		err = z.XferRateSml.EncodeMsg(en)