/**
 * Describes the set of filtered XCTests.
 *
 * NOTE: Eventually we want to support regular Java-like test filtering, like filtering for a set of test cases
 * or test suites that match a particular pattern.  Unfortunately, XCTest is very limited with how much up-front
 * test discovery we can do and the kind of filtering we can specify from the command-line.  This class reflects
 * those limitations.
 */
public class XCTestSelection {

apiVersion: release-notes/v2
kind: feature
area: istioctl
issue:
  - 27490

releaseNotes:
- |

    <testOutputDirectory>build/test</testOutputDirectory>
    <finalName>coreit</finalName>
    <resources>
      <resource>
        <directory>res/main</directory>
        <filtering>true</filtering>
        <targetPath>main</targetPath>
        <includes>
          <include>main.included</include>
        </includes>
        <excludes>
          <exclude>main.excluded</exclude>

    val collection: FileCollection = collection
    val projectDirectory = layout.projectDirectory
    doLast {
        // tag::filtering-file-collections[]
        val textFiles: FileCollection = collection.filter { f: File ->
            f.name.endsWith(".txt")
        }
        // end::filtering-file-collections[]

        textFiles.map { it.relativeTo(projectDirectory.asFile).path }.sorted().forEach { path: String ->

import javax.annotation.Nullable;

/**
 * Details about an artifact resolution query. This is used whenever repository
 * content filtering is in place.
 * <p></p>
 * This interface gives access to the details of the artifact query. There are two
 * cases when filtering can be called:
 * <p></p>
 * <ul>
 *     <li>when looking for a specific module version, for example org:foo:1.0</li>

    EXPECT_THAT(s.message(), HasSubstr("Second diagnostic message reported"));
  }
}

TEST(ErrorUtilTest, StatusScopedDiagnosticHandlerWithFilter) {
  // Filtering logic is based on tensorflow::IsInternalFrameForFilename()
  // Note we are surfacing the locations that are NOT internal frames
  // so locations that fail IsInternalFrameForFilename() evaluation pass the
  // filter.

// license that can be found in the LICENSE file.

package ast

import (
	"go/token"
	"slices"
)

// ----------------------------------------------------------------------------
// Export filtering

// exportFilter is a special filter function to extract exported nodes.
func exportFilter(name string) bool {
	return IsExported(name)
}

// FileExports trims the AST for a Go source file in place such that

            it.get("specialItem") == null
        }
    }

    def "all(Action) respects chained filtering"() {
        expect:
        accessedBy { map, action -> map.withType(specialItemClass).all(action) } == ["specialItem"]
    }

    def "all(DeferredModelAction) respects chained filtering"() {
        expect:

...but continue reading below to see how to overcome that.

## Return Type and Data Filtering

Let's continue from the previous example. We wanted to **annotate the function with one type** but return something that includes **more data**.

We want FastAPI to keep **filtering** the data using the response model.

    <testOutputDirectory>build/test</testOutputDirectory>
    <finalName>coreit</finalName>
    <resources>
      <resource>
        <directory>res/main</directory>
        <filtering>true</filtering>
        <targetPath>main</targetPath>
        <includes>
          <include>main.included</include>
        </includes>
        <excludes>
          <exclude>main.excluded</exclude>