void testPreAndPostProcessing() throws BeanConfigurationException {
        SomeBean bean = new SomeBean();

        Xpp3Dom config = toConfig("<file>${test}</file>");

        BeanConfigurationValuePreprocessor preprocessor = (value, type) -> {
            if (value != null && value.startsWith("${") && value.endsWith("}")) {
                return value.substring(2, value.length() - 1);
            }
            return value;
        };

 */
package org.gradle.language.nativeplatform.internal;

import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * An immutable snapshot of the preprocessor directives from a source or header file.
 */
public interface IncludeDirectives {
    List<Include> getQuotedIncludes();
    List<Include> getSystemIncludes();
    List<Include> getMacroIncludes();

	-v
		Print debug output.

Input language:

The assembler uses mostly the same syntax for all architectures,
the main variation having to do with addressing modes. Input is
run through a simplified C preprocessor that implements #include,
#define, #ifdef/endif, but not #if or ##.

For more information, see https://golang.org/doc/asm.
*/

 * limitations under the License.
 */

package org.gradle.language.nativeplatform.internal;

import javax.annotation.Nullable;
import java.util.List;

/**
 * A preprocessor expression whose value may be resolved to an include file path.
 * All implementations should be immutable.
 */
public interface Expression {
    /**
     * Returns the expression formatted as text in a source file.

import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
import org.jetbrains.kotlin.test.model.DependencyKind
import org.jetbrains.kotlin.test.preprocessors.ExternalAnnotationsSourcePreprocessor
import org.jetbrains.kotlin.test.services.TestModuleStructure
import org.jetbrains.kotlin.test.services.TestServices

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.api.plugins.antlr.internal.antlr2;

import antlr.preprocessor.Hierarchy;

import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;

/**

//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \
  do { \

//
// Note that even though the implementations of the following two
// macros are much alike, we cannot refactor them to use a common
// helper macro, due to some peculiarity in how the preprocessor
// works.  The AcceptsMacroThatExpandsToUnprotectedComma test in
// gtest_unittest.cc will fail to compile if we do that.
#define EXPECT_FATAL_FAILURE(statement, substr) \
  do { \

 public:
  explicit Renderer(RendererContext context);

 protected:
  // Append a blank line.
  Renderer &BlankLine();

  // Append a line of source code, left-justified (not indented).
  // Use for preprocessors directives ("#include"), namespaces, etc.
  Renderer &CodeLine(const string &text);
  template <typename... Args>
  Renderer CodeLine(absl::string_view text, const Args &...args) {

        and:
        succeeds "mainExecutable"

        and:
        skipped compileTask
    }

    @ToBeFixedForConfigurationCache
    def "source is not recompiled when preprocessor removed header is changed"() {
        given:
        def notIncluded = file("src/main/headers/notIncluded.h")
        notIncluded.text = """#pragma message("should not be used")"""
        sourceFile << """