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

package org.gradle.language.cpp

import org.gradle.language.LanguageTaskNames

abstract trait CppTaskNames extends LanguageTaskNames {
    @Override
    String getLanguageTaskSuffix() {
        return 'Cpp'
    }

package org.gradle.nativeplatform.fixtures

import org.gradle.internal.os.OperatingSystem
import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
import org.gradle.test.fixtures.file.TestFile


trait HostPlatform {
    NativeInstallationFixture installation(Object installDir, OperatingSystem os = OperatingSystem.current()) {
        if (installDir instanceof TestFile) {

 * limitations under the License.
 */

package org.gradle.smoketests

import groovy.transform.SelfType
import org.gradle.util.GradleVersion

@SelfType(BaseDeprecations)
trait WithAndroidDeprecations {

    void expectFilteredFileCollectionDeprecationWarning() {
        // This warning is emitted by the Kotlin Kapt plugin
        runner.expectLegacyDeprecationWarning(

import v1 "k8s.io/api/core/v1"

// DoNotScheduleTaintsFilterFunc returns the filter function that can
// filter out the node taints that reject scheduling Pod on a Node.
func DoNotScheduleTaintsFilterFunc() func(t *v1.Taint) bool {
	return func(t *v1.Taint) bool {
		// PodToleratesNodeTaints is only interested in NoSchedule and NoExecute taints.
		return t.Effect == v1.TaintEffectNoSchedule || t.Effect == v1.TaintEffectNoExecute
	}

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

package v1

import "fmt"

// MatchTaint checks if the taint matches taintToMatch. Taints are unique by key:effect,
// if the two taints have same key:effect, regard as they match.
func (t *Taint) MatchTaint(taintToMatch *Taint) bool {
	return t.Key == taintToMatch.Key && t.Effect == taintToMatch.Effect
}

// Replaces `TF_BatchFunctionOp` into `TF_PartitionedCallOp` that calls the
// same $f. This may be required, for example, when inlining is desired,
// because `TF_BatchFunctionOp` doesn't have the `CallOpInterface` trait.
def ReplaceBatchFunctionOpToPartitionedCallOp : Pat<
  (TF_BatchFunctionOp:$src_op_res
      $_, $_, $f, $_, $_, $_, $_, $_, $_, $_, $_, $_, $_, $_, $_, $_, $_),
  (TF_PartitionedCallOp

	"github.com/spf13/pflag"

	"istio.io/istio/pkg/log"
)

// WaitSignal awaits for SIGINT or SIGTERM and closes the channel
func WaitSignal(stop chan struct{}) {
	sigs := make(chan os.Signal, 1)
	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
	<-sigs
	close(stop)
	_ = log.Sync()
}

// WaitSignalFunc awaits for SIGINT or SIGTERM and calls the cancel function
func WaitSignalFunc(cancel func()) {

package org.gradle.integtests.fixtures

import groovy.transform.SelfType

/**
 * Allows adding methods to the test class that are useful for testing configuration usage changes.
 */
@SelfType(AbstractIntegrationSpec)
trait ConfigurationUsageChangingFixture {
    void expectConsumableChanging(String configurationPath, boolean value) {
        expectChangingUsage(configurationPath, "setCanBeConsumed", value)
    }

	}

	if opts.registerTaintsUsingFlags && opts.nodeRegOpts.Taints != nil && len(opts.nodeRegOpts.Taints) > 0 {
		taintStrs := []string{}
		for _, taint := range opts.nodeRegOpts.Taints {
			taintStrs = append(taintStrs, taint.ToString())
		}
		kubeletFlags = append(kubeletFlags, kubeadmapi.Arg{Name: "register-with-taints", Value: strings.Join(taintStrs, ",")})
	}

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

package org.gradle.api.internal.provider

import org.gradle.api.Task

trait ProviderAssertions {
    void assertHasNoProducer(ProviderInternal<?> provider) {
        def producer = provider.producer
        assert !producer.known
        producer.visitProducerTasks { assert false }