*(*ptr)->tensor() = value;
                                (*ptr)->is_initialized = true;
                                return absl::OkStatus();
                              }));
  mutex_lock ml(*variable->mu());
  OP_REQUIRES(
      context,
      !variable->is_initialized || variable->tensor()->dtype() == dtype_,
      errors::InvalidArgument(

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// depBaseInternal is only imported by depBase.

package depBaseInternal

var Initialized bool

func init() {
	Initialized = true

//
// -- if input storage class is empty then standard is assumed
//
// -- if input is RRS but RRS is not configured/initialized '-1' parity
//
//	for RRS is assumed, the caller is expected to choose the right parity
//	at that point.
//
// -- if input is STANDARD but STANDARD is not configured/initialized '-1' parity
//
//	is returned, the caller is expected to choose the right parity
//	at that point.

        synchronized (BeanDescFactory.class) {
            if (!initialized) {
                DisposableUtil.add(BeanDescFactory::clear);
                initialized = true;
            }
        }
    }

    /**
     * キャッシュをクリアします。
     */
    public static void clear() {
        beanDescCache.clear();
        initialized = false;
    }

	} else {
		sys.store = &IAMStoreSys{newIAMEtcdStore(etcdClient, sys.usersSysType), &singleflight.Group{}}
	}
}

// Initialized checks if IAM is initialized
func (sys *IAMSys) Initialized() bool {
	if sys == nil {
		return false
	}
	sys.Lock()
	defer sys.Unlock()
	return sys.store != nil
}

    }

    /**
     * 初期化します。
     */
    protected static synchronized void initialize() {
        if (!initialized) {
            DisposableUtil.add(() -> {
                ResourceBundle.clearCache();
                initialized = false;
            });
            initialized = true;
        }
    }

type Version struct {
	PatchVersion
	Suffix string
}

// NewMajorVersion creates an initialized MajorVersion struct.
func NewMajorVersion(major uint32) MajorVersion {
	return MajorVersion{
		Major: major,
	}
}

// NewMinorVersion creates an initialized MinorVersion struct.
func NewMinorVersion(major, minor uint32) MinorVersion {
	return MinorVersion{

package dep2

import "testshared/depBase"

func init() {
	if !depBase.Initialized {
		panic("depBase not initialized")
	}
}

var W int = 1

var hasProg depBase.HasProg

type Dep2 struct {
	depBase.Dep
}

func G() int {
	return depBase.F() + 1

    static NativeServices nativeServices;
    static boolean initialized;

    public static synchronized void initialize() {
        if (!initialized) {
            System.setProperty("org.gradle.native", "true");
            File nativeDir = getNativeServicesDir();
            NativeServices.initializeOnDaemon(nativeDir, NativeServicesMode.fromSystemProperties());
            initialized = true;
        }
    }

// returns an error
func TestMetricsDuRequireRealDirectory(t *testing.T) {
	metrics := NewMetricsDu("/not/a/real/directory")
	actual, err := metrics.GetMetrics()
	expected := &Metrics{}
	if !volumetest.MetricsEqualIgnoreTimestamp(actual, expected) {
		t.Errorf("Expected empty Metrics from incorrectly initialized MetricsDu, actual %v", *actual)
	}