then:
        nativeDir.exists() == initialized

        where:
        // Works for all cases except -D$NATIVE_SERVICES_OPTION=false
        description       | systemProperties                    | initialized
        "initialized"     | ["-D$NATIVE_SERVICES_OPTION=true"]  | true
        "not initialized" | ["-D$NATIVE_SERVICES_OPTION=false"] | true // Should be false
        "initialized"     | ["-D$NATIVE_SERVICES_OPTION=''"]    | true

      arg.definition_stack_trace = variable.definition_stack_trace();
      if (variable.var() && variable.var()->is_initialized) {
        const Tensor* value = variable.var()->tensor();
        arg.type = value->dtype();
        arg.shape = value->shape();
        arg.initialized = true;
      } else {
        // The values of uninitialized variables are not passed as inputs, since

    private volatile boolean initialized;
    // "value" does not need to be volatile;
    // visibility piggybacks on volatile read of "initialized".
    private T value;

    public LockingLazy(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    @Override
    public T get() {
        // A 2-field variant of Double Checked Locking.
        if (!initialized) {
            synchronized (this) {

        cache.open()

        then:
        initialized

        cleanup:
        cache.close()
    }

    def "will rebuild cache if cache.properties is missing and properties are not empty"() {
        given:
        def dir = createCacheDir()
        def initialized = false
        def init = { initialized = true } as Consumer
        def properties = [foo: 'bar']

	procAuxv = "/proc/self/auxv"

	uintSize = int(32 << (^uint(0) >> 63))
)

// For those platforms don't have a 'cpuid' equivalent we use HWCAP/HWCAP2
// These are initialized in cpu_$GOARCH.go
// and should not be changed after they are initialized.
var hwCap uint
var hwCap2 uint

func readHWCAP() error {
	// For Go 1.21+, get auxv from the Go runtime.
	if a := getAuxv(); len(a) > 0 {
		for len(a) >= 2 {

	}
	s, err := p.Lookup("F")
	if err != nil {
		panic(err)
	}

	f := s.(func(string) *unicode.RangeTable)
	if f("C") == nil {
		panic("unicode.Categories not properly initialized")
	} else {
		fmt.Println("unicode.Categories properly initialized")
	}

				} else {
					// if the slice cap is externally initialized, the externally initialized slice is directly used here
					if reflectValue.Cap() == 0 {
						db.Statement.ReflectValue.Set(reflect.MakeSlice(reflectValue.Type(), 0, 20))
					} else {
						reflectValue.SetLen(0)
						db.Statement.ReflectValue.Set(reflectValue)
					}
				}
			}

			for initialized || rows.Next() {
			BEGIN:
				initialized = false

    private final List<VisualStudioInstallCandidate> installs = new ArrayList<>();
    private boolean initialized;

    @Nonnull
    @Override
    public List<VisualStudioInstallCandidate> getVisualStudioInstalls() {
        if (!initialized) {
            installs.addAll(locateInstalls());
            initialized = true;
        }

        return installs;
    }

 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(MarkInitializedVariablesTestPass)

  StringRef getArgument() const final {
    return "tf-saved-model-mark-initialized-variables-test";
  }

  StringRef getDescription() const final {
    return "Mark variables as initialized or not.";
  }

  void runOnOperation() override {
    TF::test_util::FakeSession session;

		_, ok := LatencyTrackersFrom(parent)
		if ok {
			t.Error("expected LatencyTrackersFrom to not be initialized")
		}

		clk := clocktesting.FakeClock{}
		ctx := WithLatencyTrackersAndCustomClock(parent, &clk)
		wd, ok := LatencyTrackersFrom(ctx)
		if !ok {
			t.Error("expected LatencyTrackersFrom to be initialized")
		}