pkg go/build/constraint, method (*AndExpr) Eval(func(string) bool) bool
pkg go/build/constraint, method (*AndExpr) String() string
pkg go/build/constraint, method (*NotExpr) Eval(func(string) bool) bool
pkg go/build/constraint, method (*NotExpr) String() string
pkg go/build/constraint, method (*OrExpr) Eval(func(string) bool) bool
pkg go/build/constraint, method (*OrExpr) String() string

func AssertEqual(x, y interface{}) bool {
	if reflect.DeepEqual(x, y) {
		return true
	}
	if x == nil || y == nil {
		return false
	}

	xval := reflect.ValueOf(x)
	yval := reflect.ValueOf(y)
	if xval.Kind() == reflect.Ptr && xval.IsNil() ||
		yval.Kind() == reflect.Ptr && yval.IsNil() {
		return false
	}

	if valuer, ok := x.(driver.Valuer); ok {
		x, _ = valuer.Value()
	}

func jsonToValue(result any) (*Value, error) {
	switch rval := result.(type) {
	case string:
		return FromString(rval), nil
	case float64:
		return FromFloat(rval), nil
	case int64:
		return FromInt(rval), nil
	case uint64:
		if rval <= math.MaxInt64 {
			return FromInt(int64(rval)), nil
		}
		return FromFloat(float64(rval)), nil
	case bool:
		return FromBool(rval), nil
	case jstream.KVS:

    /**
     * Sets a character as a word character.
     *
     * @param ctype2
     *            The array of character types.
     * @param val
     *            The character code.
     */
    protected static void wordChar(final byte[] ctype2, final int val) {
        ctype2[val] |= CT_ALPHA;
    }

    /**
     * Sets characters as whitespace.
     *
     * @param ctype2

		var result []any
		for _, a := range arr {
			rval, flatten, err := jsonpathEval(p[1:], a)
			if err != nil {
				return nil, false, err
			}

			if flatten {
				// Flatten if array.
				if arr, ok := rval.([]any); ok {
					result = append(result, arr...)
					continue
				}
			}
			result = append(result, rval)
		}
		return result, true, nil
	}
	panic("cannot reach here")

      this.trueValue = trueValue;
      this.toString = toString;
    }

    @Override
    public int compare(Boolean a, Boolean b) {
      int aVal = a ? trueValue : 0;
      int bVal = b ? trueValue : 0;
      return bVal - aVal;
    }

    @Override
    public String toString() {
      return toString;
    }
  }

  /**

            keysi++;
            fval = SP7[work & 0x0000003f];
            fval |= SP5[work >>> 8 & 0x0000003f];
            fval |= SP3[work >>> 16 & 0x0000003f];
            fval |= SP1[work >>> 24 & 0x0000003f];
            work = right ^ keys[keysi++];
            fval |= SP8[work & 0x0000003f];
            fval |= SP6[work >>> 8 & 0x0000003f];
            fval |= SP4[work >>> 16 & 0x0000003f];

    override val call: Call,
  ) : CallEvent()

  data class CacheConditionalHit(
    override val timestampNs: Long,
    override val call: Call,
  ) : CallEvent()

  data class RetryDecision(
    override val timestampNs: Long,
    override val call: Call,
    val exception: IOException,
    val retry: Boolean,
  ) : CallEvent()

  data class FollowUpDecision(

        val model = setupModelFor("release")

        val sanityCheck = model.findBuildTypeByName("SanityCheck")
        val steps = sanityCheck.steps.items
        val gradleBuildStep = gradleStep(steps, 0)
        gradleBuildStep.assertTasks("tasks")
    }

    @Test
    fun `nightly promotion build type runs three gradle invocations`() {
        val model = setupModelFor("release")

const val MAX_TEST_PROJECTS_PER_BUCKET = 10
const val PERFORMANCE_TEST_SPLIT_DIRECTORY_NAME = "performance-test-splits"

data class PerformanceTestSpec(
    val performanceTestType: PerformanceTestType,
    val os: Os,
)

class StatisticsBasedPerformanceTestBucketProvider(
    private val model: CIBuildModel,
    performanceTestDurationsJson: File,