return cache.finishBinding(logger, pod, time.Now())
}

// finishBinding exists to make tests deterministic by injecting now as an argument
func (cache *cacheImpl) finishBinding(logger klog.Logger, pod *v1.Pod, now time.Time) error {
	key, err := framework.GetPodKey(pod)
	if err != nil {
		return err
	}

	cache.mu.RLock()
	defer cache.mu.RUnlock()

	if err := sched.Cache.RemoveNode(logger, node); err != nil {
		logger.Error(err, "Scheduler cache RemoveNode failed")
	}
}

func (sched *Scheduler) addPodToSchedulingQueue(obj interface{}) {
	logger := sched.logger
	pod := obj.(*v1.Pod)
	logger.V(3).Info("Add event for unscheduled pod", "pod", klog.KObj(pod))
	if err := sched.SchedulingQueue.Add(logger, pod); err != nil {

	}
	objName, err := controller.KeyFunc(obj)
	if err != nil {
		logger.Error(err, "Failed to get key from object")
		return
	}
	logger.V(5).Info("Enqueued for sync", "objName", objName)
	queue.Add(objName)
}

func (ctrl *PersistentVolumeController) storeVolumeUpdate(logger klog.Logger, volume interface{}) (bool, error) {
	return storeObjectUpdate(logger, ctrl.volumes.store, volume, "volume")
}

          if (!buffer.isProbablyUtf8()) {
            logger.log("")
            logger.log("<-- END HTTP (${totalMs}ms, binary ${buffer.size}-byte body omitted)")
            return response
          }

          if (contentLength != 0L) {
            logger.log("")
            logger.log(buffer.clone().readString(charset))
          }

          logger.log(
            buildString {

     */
    @Rule
    public ExpectedException exception = ExpectedException.none();

    private final Logger logger = Logger.getLogger(getClass());

    /**
     * @throws Exception
     */
    @Test
    public void testGetLogger() throws Exception {
        assertThat(Logger.getLogger(getClass()), is(sameInstance(Logger.getLogger(getClass()))));
    }

    /**
     * @throws Exception
     */
    @Test

        StartParameter startParameter = settings.getStartParameter();
        logger.info("Starting Build");
        if (logger.isDebugEnabled()) {
            logger.debug("Gradle user home: {}", startParameter.getGradleUserHomeDir());
            logger.debug("Current dir: {}", startParameter.getCurrentDir());
            DeprecationLogger.whileDisabled(() -> {
                logger.debug("Settings file: {}", startParameter.getSettingsFile());

     */
    @SuppressWarnings("rawtypes")
    public static Logger getLogger(Class c) {
        return (Logger) LoggerFactory.getLogger(c);
    }

    /**
     * Returns the logger with the given name.
     *
     * @param name the logger name.
     * @return the logger. Never returns null.
     */
    public static Logger getLogger(String name) {
        return (Logger) LoggerFactory.getLogger(name);
    }

        }

        if (logger.isDebugEnabled()) {
            try {
                ManagementFactory.getRuntimeMXBean().getInputArguments().stream().forEach(s -> logger.debug("Parameter: {}", s));
                System.getProperties().entrySet().stream().forEach(e -> logger.debug("Property: {}={}", e.getKey(), e.getValue()));
                System.getenv().entrySet().forEach(e -> logger.debug("Env: {}={}", e.getKey(), e.getValue()));

    protected final Log logger;

    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);
    }

    @Override

    protected final String sourceClass;

    protected final java.util.logging.Logger logger;

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override