}
                }
                is TaskFailureResult -> {
                    addExecutedTaskPath(taskPath)
                    addFailedTaskPath(taskPath)
                }
                else -> {
                }
            }
        }
    }

    private
    fun containsFailedTest(taskPath: String): Boolean {

	defer func() {
		if err != nil {
			if xnet.IsNetworkOrHostDown(err, false) {
				h.status.Store(statusOffline)
			}
			h.failedMessages.Add(int64(payloadCount))
		} else {
			h.status.Store(statusOnline)
		}
	}()

	ctx, cancel := context.WithTimeout(ctx, timeout)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost,

        if (mod != 0) {
            outData = new char[(num + 1) * 4];
        } else {
            outData = new char[num * 4];
        }
        for (int i = 0; i < num; i++) {
            encode(inData, i * 3, outData, i * 4);
        }
        if (mod == 1) {
            encode2pad(inData, num * 3, outData, num * 4);
        } else if (mod == 2) {
            encode1pad(inData, num * 3, outData, num * 4);
        }

        listOf(PerformanceTestType.per_commit, PerformanceTestType.per_day)
    } else {
        listOf(performanceTestSpec.performanceTestType)
    }
    return performanceTestConfigurations.flatMap { configuration ->
        configuration.groups
            .filter { group ->

        }
        waitForQueryThreads(q1x, q20);
        if ( q1x.getAnswer() != null ) {
            return q1x.getAnswer();
        }
        else if ( q20.getAnswer() != null ) {
            return q20.getAnswer();
        }
        else {
            throw q1x.getException();
        }
    }


    private static void waitForQueryThreads ( QueryThread q1x, QueryThread q20 ) {

		return authTypeSignedV2
	} else if isRequestPresignedSignatureV2(r) {
		return authTypePresignedV2
	} else if isRequestSignStreamingV4(r) {
		return authTypeStreamingSigned
	} else if isRequestSignStreamingTrailerV4(r) {
		return authTypeStreamingSignedTrailer
	} else if isRequestUnsignedTrailerV4(r) {
		return authTypeStreamingUnsignedTrailer
	} else if isRequestSignatureV4(r) {
		return authTypeSigned

        if (total >= 1024) {
            return toKB(complete) + "/" + toKB(total) + " KB ";
        } else if (total >= 0) {
            return complete + "/" + total + " B ";
        } else if (complete >= 1024) {
            return toKB(complete) + " KB ";
        } else {
            return complete + " B ";
        }
    }

    private void pad(StringBuilder buffer, int spaces) {

            if (settings.getAsList("synonyms", null) != null) {
                logger.warn("synonyms values are empty.");
            } else if (settings.get("synonyms_path") != null) {
                logger.warn("synonyms_path[{}] is empty.", settings.get("synonyms_path"));
            } else {
                logger.debug("No synonym data.");
            }
        }
    }

    @Override
    public Tokenizer create() {

      int positionFloor = (int) LongMath.divide(numerator, scale, RoundingMode.DOWN);
      int remainder = (int) (numerator - positionFloor * scale);
      if (remainder == 0) {
        return dataset[positionFloor];
      } else {
        double positionFrac = (double) remainder / scale;
        return dataset[positionFloor]
            + positionFrac * (dataset[positionFloor + 1] - dataset[positionFloor]);
      }
    }
  },

  /**

			o.Create = false
			o.ID = mustGetUUID()
		} else {
			if c.fileNotFound {
				// No cache found, no entries found.
				return entries, io.EOF
			}
			if c.status == scanStateError || c.status == scanStateNone {
				o.ID = ""
				o.Create = false
				o.debugln("scan status", c.status, " - waiting a roundtrip to create")
			} else {
				// Continue listing
				o.ID = c.id