kind('dependency bundles')
            inConflict('one.cool', 'oneCool')
            getterName('getOneCoolBundle')
        })

        when:
        generate {
            library('foo', 'g:a:v')
            library('bar', 'g:a:v')
            bundle('one.cool', ['foo', 'bar'])
            bundle('oneCool', ['foo', 'bar'])

            bundle("other.cool", ['foo'])
            bundle("other_cool", ['bar'])

     *
     * @param bundle
     *            リソースバンドル。{@literal null}や空文字列であってはいけません
     * @param key
     *            キー
     * @return 指定されたキーの文字列。{@literal null}や空文字列であってはいけません
     * @see ResourceBundle#getString(String)
     */
    public static String getString(final ResourceBundle bundle, final String key) {
        assertArgumentNotNull("bundle", bundle);
        assertArgumentNotEmpty("key", key);

func TestWatcher(t *testing.T) {
	watcher := NewWatcher()

	// 1. no key cert bundle
	_, watch1 := watcher.AddWatcher()
	select {
	case bundle := <-watch1:
		t.Errorf("watched unexpected keyCertBundle: %v", bundle)
		return
	default:
	}

	key := []byte("key")
	cert := []byte("cert")
	ca := []byte("caBundle")
	// 2. set key cert bundle
	watcher.SetAndNotify(key, cert, ca)
	select {
	case <-watch1:

  return Status();
}

SavedModelV2Bundle* TFSavedModelAPI::GetBundle() { return &this->bundle_; }

TFSavedModelAPI::TFSavedModelAPI(const std::string& directory,
                                 SavedModelV2Bundle bundle,
                                 RevivedObjects revived_objects)
    : directory_(directory),
      bundle_(std::move(bundle)),
      revived_objects_(std::move(revived_objects)) {}

Status TFSavedModelAPI::Load(

        final ResourceBundle bundle = ResourceBundleUtil.getBundle("CLMessages", null, this.getClass().getClassLoader());
        assertThat(bundle, is(notNullValue()));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testGetString() throws Exception {
        final ResourceBundle bundle = ResourceBundleUtil.getBundle("CLMessages");
        assertThat(bundle.getString("ECL0001"), is(notNullValue()));

	fuzz.Fuzz(f, func(fg fuzz.Helper) {
		bundle := fuzz.Struct[trustdomain.Bundle](fg)
		push := fuzz.Struct[*model.PushContext](fg, validatePush)
		node := fuzz.Struct[*model.Proxy](fg)
		selectionOpts := model.PolicyMatcherForProxy(node)
		policies := push.AuthzPolicies.ListAuthorizationPolicies(selectionOpts)
		option := fuzz.Struct[Option](fg)
		b := New(bundle, push, policies, option)
		if b == nil {
			fg.T().Skip()

func (w *Watcher) SetAndNotify(key, cert, caBundle []byte) {
	w.mutex.Lock()
	defer w.mutex.Unlock()
	if len(key) != 0 {
		w.bundle.KeyPem = key
	}
	if len(cert) != 0 {
		w.bundle.CertPem = cert
	}
	if len(caBundle) != 0 {
		w.bundle.CABundle = caBundle
	}
	for _, ch := range w.watchers {
		select {
		case ch <- struct{}{}:
		default:
		}
	}
}

				<groupId>org.apache.felix</groupId>
				<artifactId>maven-bundle-plugin</artifactId>
				<version>5.1.9</version>
				<extensions>true</extensions>

				<configuration>
					<instructions>
						<Bundle-Version>${osgi.version}</Bundle-Version>
						<Bundle-License>LGPL</Bundle-License>
						<Bundle-Vendor>CodeLibs</Bundle-Vendor>
						<Bundle-SymbolicName>org.codelibs.jcifs</Bundle-SymbolicName>
						<Export-Package>

     """Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Gradle Tooling API
Bundle-Vendor: Gradle Inc.
Bundle-SymbolicName: org.gradle.toolingapi
Bundle-Version: ${bundleVersion}.v${qualifier}
Bundle-ClassPath: .
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Export-Package: ${packageExports}
Require-Bundle: org.slf4j.api;bundle-version="1.7.2"
"""
}

                              SavedModelBundle* const bundle) {
  TF_RETURN_IF_ERROR(ReadMetaGraphDefFromSavedModel(export_dir, tags,
                                                    &bundle->meta_graph_def));
  TF_RETURN_IF_ERROR(
      ReadSavedModelDebugInfoIfPresent(export_dir, &bundle->debug_info));
  TF_RETURN_IF_ERROR(LoadMetagraphIntoSession(
      session_options, bundle->meta_graph_def, &bundle->session));