%result = tf_executor.graph {
    tf_executor.fetch %arg0 : tensor<*xf32> {attr3 = 32 : i64, tf_executor.attr_fetch = "some_value"}
  } {attr2 = 32 : i64, tf_executor.attr1 = "value1"}

// CHECK:      tf_executor.graph {
// CHECK-NEXT:    tf_executor.fetch %{{.*}} : tensor<*xf32> {attr3 = 32 : i64, tf_executor.attr_fetch = "some_value"}
// CHECK-NEXT: } {attr2 = 32 : i64, tf_executor.attr1 = "value1"}
  func.return %result : tensor<*xf32>
}

		rune rune
		want int
	}{
		{"", 'a', -1},
		{"", '☺', -1},
		{"foo", '☹', -1},
		{"foo", 'o', 1},
		{"foo☺bar", '☺', 3},
		{"foo☺☻☹bar", '☹', 9},
		{"a A x", 'A', 2},
		{"some_text=some_value", '=', 9},
		{"☺a", 'a', 3},
		{"a☻☺b", '☺', 4},

		// RuneError should match any invalid UTF-8 byte sequence.
		{"�", '�', 0},
		{"\xff", '�', 0},
		{"☻x�", '�', len("☻x")},

		rune rune
		want int
	}{
		{"", 'a', -1},
		{"", '☺', -1},
		{"foo", '☹', -1},
		{"foo", 'o', 1},
		{"foo☺bar", '☺', 3},
		{"foo☺☻☹bar", '☹', 9},
		{"a A x", 'A', 2},
		{"some_text=some_value", '=', 9},
		{"☺a", 'a', 3},
		{"a☻☺b", '☺', 4},

		// RuneError should match any invalid UTF-8 byte sequence.
		{"�", '�', 0},
		{"\xff", '�', 0},
		{"☻x�", '�', len("☻x")},

        property.getOrElse(null) == someValue()
    }

    def "can set value using chaining method"() {
        given:
        def property = propertyWithNoValue()
        property.value(someValue())

        expect:
        property.get() == someValue()
    }

    def "can set value using provider"() {

        given:
        def property = propertyWithValue(someValue())

        when:
        def copy = property.shallowCopy()

        then:
        copy.orNull == someValue()
    }

    def "shallow copy of property does not follow changes to original"() {
        given:
        def property = propertyWithValue(someValue())

        when:
        def copy = property.shallowCopy()

        then:
        result == someValue()

        and:
        1 * spec.isSatisfiedBy(someValue()) >> true
        0 * spec._

        when:
        assert filtered.getOrNull() == someValue()
        assert filtered.getOrElse(someOtherValue()) == someValue()

        then:
        2 * spec.isSatisfiedBy(someValue()) >> true
        0 * spec._
    }

        when:
        configurationCacheRun("${setterSwitch}property=someValue")

        then:
        configurationCache.assertStateStored()
        outputContains("configuration value = someValue")
        outputContains("execution value = someValue")

        when:
        configurationCacheRun("${setterSwitch}property=someValue")

        then:
        configurationCache.assertStateLoaded()

        when:
        attributes.put(':::', 'someValue')

        then:
        thrown(ManifestException)

        when:
        attributes.put(null, 'someValue')

        then:
        thrown(ManifestException)
    }

    def testKeyValidationWithPutAll() {
        when:
        attributes.putAll(':::': 'someValue')

        then:
        thrown(ManifestException)

        when:

from docs_src.query_params_str_validations.tutorial014 import app

client = TestClient(app)


def test_hidden_query():
    response = client.get("/items?hidden_query=somevalue")
    assert response.status_code == 200, response.text
    assert response.json() == {"hidden_query": "somevalue"}


def test_no_hidden_query():
    response = client.get("/items")
    assert response.status_code == 200, response.text

        DummyModel actual = new DummyModel() {
            @Override
            String getValue() {
                return "someValue"
            }
        }

        when:
        ToolingApiModelChecker.checkModel(
            actual,
            dummyModel("someValue"),
            [
                { it.value }
            ]
        )

        then:
        noExceptionThrown()
    }