"MOVFW",
	"MOVH",
	"MOVHU",
	"MOVW",
	"MOVWD",
	"MOVWF",
	"MOVWL",
	"MOVWR",
	"MSUB",
	"MUL",
	"MULD",
	"MULF",
	"MULU",
	"MULW",
	"NEGD",
	"NEGF",
	"NEGW",
	"NEGV",
	"NOOP",
	"NOR",
	"OR",
	"REM",
	"REMU",
	"RFE",
	"ROTR",
	"ROTRV",
	"SC",
	"SCV",
	"SEB",
	"SEH",
	"SGT",
	"SGTU",
	"SLL",
	"SQRTD",
	"SQRTF",
	"SRA",
	"SRL",
	"SUB",

        Container(String parentName, String name, Closure factory) {
            super(Object, TestUtil.instantiatorFactory().decorateLenient(), new DynamicPropertyNamer(), factory, MutationGuards.identity(), CollectionCallbackActionDecorator.NOOP)
            this.parentName = parentName
            this.name = name
        }
    }

    def "can nest auto creation configure closures"() {
        given:

import spock.lang.Specification

class CreateDefaultFlavorsTest extends Specification {
    def flavorContainer = new DefaultFlavorContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)
    def rule = new NativeComponentModelPlugin.Rules()

    def "has a single default flavor when not configured"() {
        when:
        rule.createDefaultFlavor(flavorContainer)

        then:

        given:
        settingsFile << """
            pluginManagement {
                resolutionStrategy.eachPlugin {
                    if(requested.id.name == 'noop') {
                        useModule('com.acme:foo:+')
                    }
                }
                repositories {
                    maven {
                        url "http://repo.internal.net/m2"

   * [WindowCounter] generally carries the client view of total and acked bytes.
   */
  fun receivingConnectionWindowChanged(windowCounter: WindowCounter)

  /** Noop implementation */
  object None : FlowControlListener {
    override fun receivingStreamWindowChanged(
      streamId: Int,
      windowCounter: WindowCounter,
      bufferSize: Long,
    ) {
    }

            return BaseBinarySpec.create(publicType, implType, identifier, node, componentNode, TestUtil.instantiatorFactory().injectLenient(), {} as NamedEntityInstantiator, CollectionCallbackActionDecorator.NOOP, TestUtil.domainObjectCollectionFactory())
        }
    }

class DefaultAuthenticationContainerTest extends Specification {
    @Subject
    def container = new DefaultAuthenticationContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)

    def setup() {
        container.registerBinding(TestAuthentication, DefaultTestAuthentication)
        container.registerBinding(CustomTestAuthentication, DefaultCustomTestAuthentication)
    }

  %0 = "tf.AddV2"(%arg0, %cst) {device = "/device:CPU:0"} : (tensor<f32>, tensor<f32>) -> tensor<f32>
  %1 = "tf.Identity"(%0) {device = ""} : (tensor<f32>) -> tensor<f32>
  "tf.NoOp"() {device = ""} : () -> ()
  func.return %1 : tensor<f32>
  // CHECK: func @three_dialects
  // CHECK-NEXT: glue.constant
  // CHECK-NEXT: glue.compare
  // CHECK-NEXT: call{{.*}}mhlo
  // CHECK-NEXT: call{{.*}}tf

}

// Populates an empty IslandOp and with a NoOp or Identity/IdentityN depending
// on if there are any data results.
void PopulateEmptyIsland(tf_executor::IslandOp island) {
  OpBuilder builder(&island.GetBody(), island.GetBody().begin());
  tf_executor::YieldOp yield = island.GetYield();
  if (yield.getNumOperands() == 0) {
    builder.create<TF::NoOp>(island.getLoc(), TypeRange{}, ValueRange{});

*/

package filters

import (
	"net/http"
	"net/http/httptest"
	"testing"
)

func noopHandler() http.HandlerFunc {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		// noop
	})
}

func TestWithContentType(t *testing.T) {
	mux := http.NewServeMux()
	mux.Handle("/text", WithContentType(noopHandler(), "text/plain"))
	mux.Handle("/json", WithContentType(noopHandler(), "application/json"))