package org.gradle.internal.cc.impl.inputs.undeclared

import org.gradle.api.Action
import org.gradle.api.Plugin
import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.test.fixtures.file.TestFile

trait JavaPluginImplementation {
    void javaPlugin(TestFile sourceFile, BuildInputRead read) {
        sourceFile << """
            import ${Action.name};
            import ${Project.name};
            import ${Plugin.name};

        String action = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";
        String direction = event.getRequestType() == TransferEvent.RequestType.PUT ? "to" : "from";

        TransferResource resource = event.getResource();
        MessageBuilder message = messageBuilderFactory.builder();
        message.style(STYLE).append(action).append(' ').append(direction).append(' ');

    }

    private
    fun <T> roundtripOf(action: TestableIsolatedAction<T>): TestableIsolatedAction<T> =
        deserialize(serialize(action))

    private
    fun <T> serialize(action: TestableIsolatedAction<T>) =
        IsolatedActionSerializer(ownerGradle(), DefaultBeanStateWriterLookup(), isolatedActionCodecsFactory())
            .serialize(action)

    private

        String action = event.getRequestType() == TransferEvent.RequestType.PUT ? "Uploading" : "Downloading";
        String direction = event.getRequestType() == TransferEvent.RequestType.PUT ? "to" : "from";

        TransferResource resource = event.getResource();
        StringBuilder message = new StringBuilder();

     */
    fun <T : Any> useForStateLoad(action: (ConfigurationCacheRepository.Layout) -> T): T

    /**
     * Loads some value from a specific state file.
     */
    fun <T : Any> useForStateLoad(stateType: StateType, action: (ConfigurationCacheStateFile) -> T): T

    /**
     * Writes some value to zero or more state files.
     */
    fun <T> useForStore(action: (ConfigurationCacheRepository.Layout) -> T): T

    /**

// Error sends an Error event.
func (f *FakeWatcher) Error(errValue runtime.Object) {
	f.result <- Event{Error, errValue}
}

// Action sends an event of the requested type, for table-based testing.
func (f *FakeWatcher) Action(action EventType, obj runtime.Object) {
	f.result <- Event{action, obj}
}

// RaceFreeFakeWatcher lets you test anything that consumes a watch.Interface; threadsafe.
type RaceFreeFakeWatcher struct {

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

package org.gradle.cache.internal

import org.gradle.api.Action
import org.gradle.cache.internal.scopes.DefaultCacheScopeMapping
import org.gradle.cache.internal.scopes.DefaultGlobalScopedCacheBuilderFactory
import org.gradle.internal.instrumentation.agent.AgentStatus

            on { tryGetProperty(any()) }.thenReturn(DynamicInvokeResult.found())
        }

        fun shouldTrackContext(action: DynamicLookupRoutine.() -> Unit) {
            val tracker = mock<DynamicCallContextTracker>()
            val routine = TrackingDynamicLookupRoutine(tracker)
            action(routine)
            verify(tracker, times(1)).enterDynamicCall(receiver)
            verify(tracker, times(1)).leaveDynamicCall(receiver)

     * ```
     * // compiled library
     * fun foo(): (bar: String) -> Unit { ... }
     *
     * // source code
     * fun test() {
     *   val action = foo()
     *   action("") // this call
     * }
     * ```
     *
     * Unfortunately, [symbol] for the `action("")` call will be pointing to the `Function1<P1, R>.invoke(p1: P1): R`, because we

            // We should always be using JUnitPlatform at this point, so don't call useJUnitPlatform(), else this will
            // discard existing options configuration and add a deprecation warning.  Just set the existing options.
            (this.testFramework.options as JUnitPlatformOptions).includeEngines("cross-version-test-engine")
        }
        if (executer == defaultExecuter) {