final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("ggg");
        propDesc.setValue(myBean, new Integer(1));
        assertThat(myBean.getGgg(), is(new BigDecimal(1)));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSetTimestampValue() throws Exception {
        final MyBean myBean = new MyBean();

		// observe this.
		throw("self deadlock")
	}
	gp := getg()
	if gp.m.locks < 0 {
		throw("lock count")
	}
	gp.m.locks++
	l.key = mutex_locked
}

func unlock(l *mutex) {
	unlockWithRank(l)
}

func unlock2(l *mutex) {
	if l.key == mutex_unlocked {
		throw("unlock of unlocked lock")
	}
	gp := getg()
	gp.m.locks--
	if gp.m.locks < 0 {
		throw("lock count")
	}

public interface DaemonFixture {
    /**
     * Returns the context information of this daemon.
     */
    DaemonContext getContext();

    /**
     * Returns the log for this daemon.
     */
    String getLog();

    /**
     * Returns the log file for this daemon.
     */
    File getLogFile();

    /**
     * Returns whether the log file contains a given String.
     *

      device_mgr_.get(), Env::Default(), /*config=*/nullptr,
      TF_GRAPH_DEF_VERSION, lib_def_.get(), opts,
      /*default_thread_pool=*/nullptr, /*cluster_flr=*/nullptr);
  flr_ = pflr_->GetFLR("/job:localhost/replica:0/task:0/cpu:0");
}

Device* DeviceSetup::GetDevice(const string& device_name) {
  if (device_mgr_ == nullptr) {
    return nullptr;
  }

  string full_device_name = absl::StrCat(

        return result;
    }

    private static List<RequestExtra> modifiedExtras(RequestExtrasContainer originalExtras) {
        return Stream.of(
            originalExtras.getAll().stream().filter(it -> !(it instanceof WithExtensionReferencesExtra)),
            Stream.<RequestExtra>of(new WithExtensionReferencesExtra.ProducedSynthetically())
        ).flatMap(Function.identity()).collect(Collectors.toList());

    }

    @Test
    void testGetLogger() {
        ToolchainModel model = new ToolchainModel();
        DefaultToolchain toolchain = newDefaultToolchain(model);
        assertEquals(logger, toolchain.getLog());
    }

    @Test
    void testMissingRequirementProperty() {
        ToolchainModel model = new ToolchainModel();
        model.setType("TYPE");
        DefaultToolchain toolchain = newDefaultToolchain(model);

                    map = objectFactory.mapProperty(Integer.class, Boolean.class);
                }

                @Internal
                public Property<Boolean> getFlag() {
                    return flag;
                }

                @Internal
                public Property<String> getMessage() {
                    return message;
                }

		t.Errorf("Got error while creating self-signed CA: %v", err)
	}
	if ca == nil {
		t.Fatalf("Failed to create a self-signed CA.")
	}

	signingCert, _, certChainBytes, rootCertBytes := ca.GetCAKeyCertBundle().GetAll()
	rootCert, err := util.ParsePemEncodedCertificate(rootCertBytes)
	if err != nil {
		t.Error(err)
	}
	// Root cert and siging cert are the same for self-signed CA.
	if !rootCert.Equal(signingCert) {

        classDependingOnBasicClassSource.create()
        independentClassSource.create()
    }

    void extra() {
        extraClass.create()
    }

    List<ScalaClass> getAll() {
        return [basicClassSource, classDependingOnBasicClassSource, independentClassSource]
    }

    List<Long> getAllClassesLastModified() {
        return all*.compiledClass*.lastModified()
    }

     * method directly whenever you need the logger, it is fast enough and needs no caching.
     *
     * @see org.apache.maven.plugin.Mojo#getLog()
     * @deprecated Use SLF4J directly
     */
    @Deprecated
    @Override
    public Log getLog() {
        if (log == null) {
            log = new SystemStreamLog();
        }

        return log;
    }

    @Override