backend_config = #vhlo.string_v1<"">,
    call_target_name = #vhlo.string_v1<"tf.ResizeBilinear">,
    called_computations = #vhlo.array_v1<[]>,
    has_side_effect = #vhlo.bool_v1<false>,
    operand_layouts = #vhlo.array_v1<[]>,
    output_operand_aliases = #vhlo.array_v1<[]>,

            size: 1
          }
        }
        string_val: "value"
      }
    }
  }
}
node {
  name: "Const_1"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_STRING
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_STRING
        tensor_shape {
        }
        string_val: "value"
      }
    }
  }
}
node {

  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_STRING
        tensor_shape {
          dim {
            size: 2
          }
        }
        string_val: "feature_key3"
        string_val: "feature_key4"
      }
    }
  }
}
node {
  name: "ParseExample/ParseExampleV2/dense_keys"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_STRING

}

TEST(ValueTest, TestString) {
  TaggedValue value1a("string1");
  std::string s = "string";
  s += "1";
  TaggedValue value1b(s.c_str());
  // Verify that interned the pointers are the same.
  ASSERT_EQ(value1b.s(), value1a.s());
  TaggedValue value2("string2");
  ASSERT_NE(value1a.s(), value2.s());
  ASSERT_STREQ(value1a.s(), "string1");
  ASSERT_STREQ(value2.s(), "string2");
}

TEST(Test1, TestDict) {

        def string1 = "foo"
        def string2 = "bar"
        Isolatable<?>[] isolatables = [isolatableFactory.isolate(string1), isolatableFactory.isolate(string2)]

        when:
        serialize(isolatables)

        and:
        Isolatable<?>[] newIsolatables = deserialize()

        then:
        newIsolatables[0].isolate() == string1
        newIsolatables[1].isolate() == string2
    }

  /*

  */  \\
  #/*


  */\u0000define \\
        /*
         */STRING_2\\
/*
*/"123"\\
    /* */   // some extra"""

        then:
        macros == [macro('SOME_STRING', 'abc'), macro('STRING_2', '123')]
        macroFunctions.empty
    }

    def "finds object-like macro directive with no whitespace"() {
        when:

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

[[single-version-declarations]]
= Declaring Versions and Ranges

The simplest version declaration is a _simple string_ representing the version to use.
Gradle supports different ways of declaring a version string:

* An exact version: e.g. `1.3`, `1.3.0-beta3`, `1.0-20150201.131010-1`

| policy     | _string_ or _[]string_ or _comma_separated_value_ | Canned policy name to be applied for STS credentials. (Mandatory) - This can be configured to any desired value such as `roles` or `groups` by setting the environment variable `MINIO_IDENTITY_OPENID_CLAIM_NAME` |

            }
            """
        )

        val taskName = ":writeInputToFile"

        build(taskName, "-PinputString=string1").assertTasksExecutedAndNotSkipped(taskName)

        build(taskName, "-PinputString=string1").assertTasksSkipped(taskName)

        build(taskName, "-PinputString=string2").assertTasksExecutedAndNotSkipped(taskName)
    }

    @Test

func bytes2(x []byte) []byte { // ERROR "leaking param: x$"
	v := reflect.ValueOf(x) // ERROR "x escapes to heap"
	return v.Bytes()
}

func string1(x string) string { // ERROR "leaking param: x to result ~r0 level=0"
	v := reflect.ValueOf(x) // ERROR "x does not escape"
	return v.String()
}

func string2(x int) string {