import org.gradle.util.internal.TextUtil

class FilesInTransformIntegrationTest extends AbstractProcessIntegrationTest {
    def setup() {
        inputFile.text = "INPUT FILE CONTENT"
    }

    def "reading a file in transform action with #task does not create a build input"() {
        given:
        getTransformFixture().tap {
            withTransformPlugin(testDirectory.createDir("buildSrc"))

	// serverside handlers.
	handlers handlers

	// local host name.
	local string

	// Validate incoming requests.
	authRequest func(r *http.Request) error
}

// ManagerOptions are options for creating a new grid manager.
type ManagerOptions struct {
	Dialer       ContextDialer               // Outgoing dialer.
	Local        string                      // Local host name.

		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			_, ctx := ktesting.NewTestContext(t)
			p, err := New(ctx, nil, nil, feature.Features{})
			if err != nil {
				t.Fatalf("Creating plugin: %v", err)
			}

			got := p.(framework.PreEnqueuePlugin).PreEnqueue(ctx, tt.pod)
			if diff := cmp.Diff(tt.want, got); diff != "" {
				t.Errorf("unexpected status (-want, +got):\n%s", diff)
			}
		})
	}

            }
        """

        when:
        configurationCacheRun "ok"

        then:
        result.output.count("creating bean") == 2

        when:
        configurationCacheRun "ok"

        then:
        outputDoesNotContain("creating bean")
        outputContains("bean.value = child")
        outputContains("bean.parent.value = parent")
        outputContains("same reference = true")

		config.DetectLocalMode = proxyconfigapi.LocalModeClusterCIDR
	}
	o.logger.V(2).Info("DetectLocalMode", "localMode", string(config.DetectLocalMode))
}

// platformSetup is called after setting up the ProxyServer, but before creating the
// Proxier. It should fill in any platform-specific fields and perform other
// platform-specific setup.
func (s *ProxyServer) platformSetup(ctx context.Context) error {
	logger := klog.FromContext(ctx)

    override fun createPointer(): KaSymbolPointer<KaFileSymbol> = withValidityAssertion {
        KaPsiBasedSymbolPointer.createForSymbolFromSource<KaFileSymbol>(this)?.let { return it }
        TODO("Creating pointers for files from library is not supported yet")
    }

    override val annotations by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

# Avoid creating a bunch of RBAC rules for features we are not enabling
rbac:
  create: false
  pspEnabled: false

# Disable test pods
testFramework:
  enabled: false

podLabels:
  sidecar.istio.io/inject: "false"

# Demo only, so we will have no authentication
admin:
  existingSecret: ""
ldap:
  existingSecret: true
env:
  GF_SECURITY_ADMIN_USER: "admin"
  GF_SECURITY_ADMIN_PASSWORD: "admin"

                    return modelName == "${BaseModel.name}"
                }
                Object buildAll(String modelName, Project project) {
                    println("creating model for \$project")
                    return new org.gradle.integtests.tooling.fixture.DefaultModel("poly from '" + project.name + "'")
                }
            }
        """.stripIndent()

errorprone {
    disabledChecks.addAll(
        "EqualsUnsafeCast", // 1 occurrences
    )
}

val implementationResources: Configuration by configurations.creating

repositories {
    googleApisJs()
}

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":base-services"))
    api(project(":core"))
    api(project(":core-api"))

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Adds support for creating dependency platforms for JVM projects"

errorprone {
    disabledChecks.addAll(
        "InlineFormatString", // 1 occurrences
    )
}

dependencies {
    api(project(":core-api"))