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: 3
          }
        }
        string_val: ""
        string_val: ""
        string_val: ""
      }
    }
  }
}
versions {
  producer: 74

  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

          tensor {
            dtype: DT_STRING
            tensor_shape {
              dim {
                size: 3
              }
            }
            string_val: "a"
            string_val: "b"
            string_val: "c"
          }
        }
      }
    }
    node {
      name: "save/SaveV2/shape_and_slices"
      op: "Const"
      attr {
        key: "_output_shapes"

}

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
    }

  attr {
    key: "dtype"
    value {
      type: DT_STRING
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_STRING
        tensor_shape {
        }
        string_val: ""
      }
    }
  }
  attr {
    key: "_output_shapes"
    value {
      list {
        shape {
        }
      }
    }
  }
}
node {
  name: "Const2"
  op: "Const"
  attr {

  /*

  */  \\
  #/*


  */\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:

			return err
		}
		var columnValue string
		switch typ {
		case simdjson.TypeNull, simdjson.TypeFloat, simdjson.TypeUint, simdjson.TypeInt, simdjson.TypeBool, simdjson.TypeString:
			val, err := tmp.StringCvt()
			if err != nil {
				return err
			}
			columnValue = val
		case simdjson.TypeObject, simdjson.TypeArray:
			b, err := tmp.MarshalJSON()
			if err != nil {
				return err
			}