return args, err
	}

	getCfg := func(cfgParam string) string {
		// As parameters are already validated, we skip checking
		// if the config param was found.
		val, _, _ := s.ResolveConfigParam(config.PolicyPluginSubSys, config.Default, cfgParam, false)
		return val
	}

	pluginURL := getCfg(URL)
	if pluginURL == "" {
		return args, nil
	}

        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("fff");
        propDesc.setValue(myBean, new BigDecimal(2));
        assertThat(myBean.getFff(), is(2));
    }

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

            RequirementMatcher matcher = provides.get(key);

            if (matcher == null) {
                getLog().debug("Toolchain {} is missing required property: {}", this, key);
                return false;
            }
            if (!matcher.matches(requirement.getValue())) {
                getLog().debug("Toolchain {} doesn't match required property: {}", this, key);
                return false;
            }
        }

    }

    @Test
    @DisplayName("getDfs should return initialized DFS resolver")
    void testGetDfs() {
        // When
        DfsResolver dfs = context.getDfs();

        // Then
        assertNotNull(dfs, "DFS resolver should not be null");
        assertSame(dfs, context.getDfs(), "Should return same instance on multiple calls");
    }

    @Test

        // Given
        DfsResolver mockResolver = mock(DfsResolver.class);
        when(mockContext.getDfs()).thenReturn(mockResolver);

        // When
        DfsResolver resolver = mockContext.getDfs();

        // Then
        assertEquals(mockResolver, resolver);
        verify(mockContext).getDfs();
    }

    @Test
    @DisplayName("Should get SidResolver")
    void testGetSIDResolver() {

    public void action() {
        FileTree kotlinDslExtensionsJar = getArchives().zipTree(getKotlinDslExtensionsJar());
        getFs().sync(spec -> {
            spec.from(kotlinDslExtensionsJar, zip -> zip.include("**/*.kt"));
            spec.into(getGeneratedSources());
        });
        getFs().sync(spec -> {
            spec.from(kotlinDslExtensionsJar, zip -> zip.include("**/*.class"));
            spec.into(getGeneratedClasses());

              <exclude>org.apache.maven.toolchain.DefaultToolchain#getLog():METHOD_RETURN_TYPE_CHANGED</exclude>
              <exclude>org.apache.maven.toolchain.DefaultToolchain#DefaultToolchain(org.apache.maven.toolchain.model.ToolchainModel,org.codehaus.plexus.logging.Logger):CONSTRUCTOR_REMOVED</exclude>

        return newContext;
    }

    @Override
    public Configuration getConfig() {
        return this.delegate.getConfig();
    }

    @Override
    public DfsResolver getDfs() {
        return this.delegate.getDfs();
    }

    @Override
    public Credentials getCredentials() {
        return this.delegate.getCredentials();
    }

    @Override

     */
    @Override
    public Configuration getConfig() {
        return this.config;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getDfs()
     */
    @Override
    public DfsResolver getDfs() {
        return this.dfs;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.CIFSContext#getNameServiceClient()
     */
    @Override

     * Creates a new instance of JclLoggerAdapter.
     *
     * @param name the logger name
     */
    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);