src/test/java/com/google/devtools/build/lib/skylark/SkylarkStringRepresentationsTest.java - bazel - Git at Google

 // Copyright 2017 The Bazel Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 package com.google.devtools.build.lib.skylark;

 import static com.google.common.truth.Truth.assertThat;

 import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
 import com.google.devtools.build.lib.skylark.util.SkylarkTestCase;
 import com.google.devtools.build.lib.util.Pair;
 import com.google.devtools.build.lib.vfs.ModifiedFileSet;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 /** Tests for string representations of Skylark objects. */
 @RunWith(JUnit4.class)
 public class SkylarkStringRepresentationsTest extends SkylarkTestCase {

   // Different ways to format objects, these suffixes are used in the `prepare_params` function
   private static final ImmutableList<String> SUFFIXES =
       ImmutableList.of("_str", "_repr", "_format", "_str_perc", "_repr_perc");

   private Object skylarkLoadingEval(String code) throws Exception {
     return skylarkLoadingEval(code, "");
   }

   /**
    * Evaluates {@code code} in the loading phase in a .bzl file
    *
    * @param code The code to execute
    * @param definition Additional code to define necessary variables
    */
   private Object skylarkLoadingEval(String code, String definition) throws Exception {
     scratch.overwriteFile("eval/BUILD", "load(':eval.bzl', 'eval')", "eval(name='eval')");
     scratch.overwriteFile(
         "eval/eval.bzl",
         definition,
         String.format("x = %s", code), // Should be placed here to execute during the loading phase
         "def _impl(ctx):",
         "  return struct(result = x)",
         "eval = rule(implementation = _impl)");
     skyframeExecutor.invalidateFilesUnderPathForTesting(
         reporter,
         new ModifiedFileSet.Builder()
             .modify(PathFragment.create("eval/BUILD"))
             .modify(PathFragment.create("eval/eval.bzl"))
             .build(),
         rootDirectory);

     ConfiguredTarget target = getConfiguredTarget("//eval");
     return target.get("result");
   }

   /**
    * Asserts that all 5 different ways to convert an object to a string of {@code expression}
    * ({@code str}, {@code repr}, {@code '%s'}, {@code '%r'}, {@code '{}'.format} return the correct
    * {@code representation}. Not applicable for objects that have different {@code str} and {@code
    * repr} representations.
    *
    * @param definition optional definition required to evaluate the {@code expression}
    * @param expression the expression to evaluate a string representation of
    * @param representation desired string representation
    */
   private void assertStringRepresentation(
       String definition, String expression, String representation) throws Exception {
     assertThat(skylarkLoadingEval(String.format("str(%s)", expression), definition))
         .isEqualTo(representation);
     assertThat(skylarkLoadingEval(String.format("repr(%s)", expression), definition))
         .isEqualTo(representation);
     assertThat(skylarkLoadingEval(String.format("'%%s' %% (%s,)", expression), definition))
         .isEqualTo(representation);
     assertThat(skylarkLoadingEval(String.format("'%%r' %% (%s,)", expression), definition))
         .isEqualTo(representation);
     assertThat(skylarkLoadingEval(String.format("'{}'.format(%s)", expression), definition))
         .isEqualTo(representation);
   }

   private void assertStringRepresentation(String expression, String representation)
       throws Exception {
     assertStringRepresentation("", expression, representation);
   }

   /**
    * Creates a set of BUILD and .bzl files that gathers objects of many different types available in
    * Skylark and creates their string representations by calling `str` and `repr` on them. The
    * strings are available in the configured target for //test/skylark:check
    */
   private void generateFilesToTestStrings() throws Exception {
     // Generate string representations of different Skylark types. Objects are generated in
     // test/skylark/rules.bzl: the top-level objects dict contains objects
     // available during the loading phase, and _check_impl(ctx) returns objects that are available
     // during the analysis phase. prepare_params(objects) converts a list of objects to a list of
     // their string representations.

     scratch.file(
         "test/skylark/rules.bzl",
         "aspect_ctx_provider = provider()",
         "def prepare_params(objects):",
         "  params = {}",
         "  for k, v in objects.items():",
         "    params[k + '_str'] = str(v)",
         "    params[k + '_repr'] = repr(v)",
         "    params[k + '_format'] = '{}'.format(v)",
         "    params[k + '_str_perc'] = '%s' % (v,)",
         "    params[k + '_repr_perc'] = '%r' % (v,)",
         "  return params",
         "",
         "def _impl_aspect(target, ctx):",
         "  return [aspect_ctx_provider(ctx = ctx)]",
         "my_aspect = aspect(implementation = _impl_aspect)",
         "",
         "def _impl(ctx): pass",
         "dep = rule(implementation = _impl)",
         "",
         "def _genfile_impl(ctx):",
         "  ctx.file_action(output = ctx.outputs.my_output, content = 'foo')",
         "genfile = rule(",
         "  implementation = _genfile_impl,",
         "  outputs = {",
         "    'my_output': '%{name}.txt',",
         "  },",
         ")",
         "",
         "def _check_impl(ctx):",
         "  objects = {",
         "    'target': ctx.attr.deps[0],",
         "    'alias_target': ctx.attr.deps[1],",
         "    'aspect_target': ctx.attr.asp_deps[0],",
         "    'input_target': ctx.attr.srcs[0],",
         "    'output_target': ctx.attr.srcs[1],",
         "    'rule_ctx': ctx,",
         "    'aspect_ctx': ctx.attr.asp_deps[0][aspect_ctx_provider].ctx,",
         "  }",
         "  return struct(**prepare_params(objects))",
         "check = rule(",
         "  implementation = _check_impl,",
         "  attrs = {",
         "    'deps': attr.label_list(),",
         "    'asp_deps': attr.label_list(aspects = [my_aspect]),",
         "    'srcs': attr.label_list(allow_files = True),",
         "  },",
         ")");

     scratch.file(
         "test/skylark/BUILD",
         "load(':rules.bzl', 'check', 'dep', 'genfile')",
         "",
         "dep(name = 'foo')",
         "dep(name = 'bar')",
         "alias(name = 'foobar', actual = ':foo')",
         "genfile(name = 'output')",
         "check(",
         "  name = 'check',",
         "  deps = [':foo', ':foobar'],",
         "  asp_deps = [':bar'],",
         "  srcs = ['input.txt', 'output.txt'],",
         ")");
   }

   @Test
   public void testStringRepresentations_Strings() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

     assertThat(skylarkLoadingEval("str('foo')")).isEqualTo("foo");
     assertThat(skylarkLoadingEval("'%s' % 'foo'")).isEqualTo("foo");
     assertThat(skylarkLoadingEval("'{}'.format('foo')")).isEqualTo("foo");
     assertThat(skylarkLoadingEval("repr('foo')")).isEqualTo("\"foo\"");
     assertThat(skylarkLoadingEval("'%r' % 'foo'")).isEqualTo("\"foo\"");
   }

   @Test
   public void testStringRepresentations_Labels() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

     assertThat(skylarkLoadingEval("str(Label('//foo:bar'))")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("'%s' % Label('//foo:bar')")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("'{}'.format(Label('//foo:bar'))")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("repr(Label('//foo:bar'))")).isEqualTo("Label(\"//foo:bar\")");
     assertThat(skylarkLoadingEval("'%r' % Label('//foo:bar')")).isEqualTo("Label(\"//foo:bar\")");

     assertThat(skylarkLoadingEval("'{}'.format([Label('//foo:bar')])")).isEqualTo("[Label(\"//foo:bar\")]");
   }

   @Test
   public void testStringRepresentations_Primitives() throws Exception {
     // Strings are tested in a separate test case as they have different str and repr values.
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

     assertStringRepresentation("1543", "1543");
     assertStringRepresentation("True", "True");
     assertStringRepresentation("False", "False");
   }

   @Test
   public void testStringRepresentations_Containers() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

     assertStringRepresentation("['a', 'b']", "[\"a\", \"b\"]");
     assertStringRepresentation("('a', 'b')", "(\"a\", \"b\")");
     assertStringRepresentation("{'a': 'b', 'c': 'd'}", "{\"a\": \"b\", \"c\": \"d\"}");
     assertStringRepresentation("struct(d = 4, c = 3)", "struct(c = 3, d = 4)");
   }

   @Test
   public void testLegacyStringRepresentations_Labels() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     assertThat(skylarkLoadingEval("str(Label('//foo:bar'))")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("'%s' % Label('//foo:bar')")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("'{}'.format(Label('//foo:bar'))")).isEqualTo("//foo:bar");
     assertThat(skylarkLoadingEval("repr(Label('//foo:bar'))")).isEqualTo("\"//foo:bar\"");
     assertThat(skylarkLoadingEval("'%r' % Label('//foo:bar')")).isEqualTo("\"//foo:bar\"");

     // Also test that str representations (as opposed to repr) also use legacy formatting
     // They are equivalent for labels, but not equivalent for lists of labels, because
     // containers always render their items with repr
     assertThat(skylarkLoadingEval("str([Label('//foo:bar')])")).isEqualTo("[\"//foo:bar\"]");
     assertThat(skylarkLoadingEval("'{}'.format([Label('//foo:bar')])")).isEqualTo("[\"//foo:bar\"]");
     assertThat(skylarkLoadingEval("'%s' % [Label('//foo:bar')]")).isEqualTo("[\"//foo:bar\"]");
   }

   @Test
   public void testLegacyStringRepresentations_Functions() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     assertStringRepresentation("all", "<function all>");
     assertStringRepresentation("def f(): pass", "f", "<function f>");
   }

   @Test
   public void testLegacyStringRepresentations_Rules() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     assertStringRepresentation("native.cc_library", "<function cc_library>");
     assertStringRepresentation("rule(implementation=str)", "<function rule>");
     assertStringRepresentation("aspect(implementation=str)", "Aspect:<function str>");
   }

   @Test
   public void testLegacyStringRepresentations_Providers() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     assertStringRepresentation("provider()", "<function <no name>>");
     assertStringRepresentation("p = provider()", "p(b = 2, a = 1)", "p(a = 1, b = 2)");
   }

   @Test
   public void testLegacyStringRepresentations_Select() throws Exception {
     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     assertStringRepresentation(
         "select({'//foo': ['//bar']}) + select({'//foo2': ['//bar2']})",
         "selector({\"//foo\": [\"//bar\"]}) + selector({\"//foo2\": [\"//bar2\"]})");
   }

   @Test
   public void testLegacyStringRepresentations_Targets() throws Exception {
     // alias targets in skylark used to leak their memory addresses in string representations,
     // we don't try to preserve this behaviour as it's harmful.
     // An example of their legacy representation:
     // "<com.google.devtools.build.lib.rules.AliasConfiguredTarget@12da9140>"

     setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

     generateFilesToTestStrings();
     ConfiguredTarget target = getConfiguredTarget("//test/skylark:check");


     ImmutableList<Pair<String, String>> parameters = ImmutableList.of(
         new Pair<>("rule_ctx", "//test/skylark:check"),
         new Pair<>("aspect_ctx", "//test/skylark:bar"),
         new Pair<>("input_target", "InputFileConfiguredTarget(//test/skylark:input.txt)"));
     for (String suffix : SUFFIXES) {
       for (Pair<String, String > pair : parameters) {
         assertThat(target.get(pair.getFirst() + suffix)).isEqualTo(pair.getSecond());
       }
     }

     // Legacy representation of several types of objects may contain nondeterministic chunks
     parameters = ImmutableList.of(
         new Pair<>("target", "ConfiguredTarget\\(//test/skylark:foo, [0-9a-f]+\\)"),
         new Pair<>("aspect_target", "ConfiguredTarget\\(//test/skylark:bar, [0-9a-f]+\\)"),
         new Pair<>("output_target", "ConfiguredTarget\\(//test/skylark:output.txt, [0-9a-f]+\\)"));
     for (String suffix : SUFFIXES) {
       for (Pair<String, String > pair : parameters) {
         assertThat((String) target.get(pair.getFirst() + suffix)).matches(pair.getSecond());
       }
     }
   }
 }
	// Copyright 2017 The Bazel Authors. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.
	package com.google.devtools.build.lib.skylark;

	import static com.google.common.truth.Truth.assertThat;

	import com.google.common.collect.ImmutableList;
	import com.google.devtools.build.lib.analysis.ConfiguredTarget;
	import com.google.devtools.build.lib.skylark.util.SkylarkTestCase;
	import com.google.devtools.build.lib.util.Pair;
	import com.google.devtools.build.lib.vfs.ModifiedFileSet;
	import com.google.devtools.build.lib.vfs.PathFragment;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	/** Tests for string representations of Skylark objects. */
	@RunWith(JUnit4.class)
	public class SkylarkStringRepresentationsTest extends SkylarkTestCase {

	// Different ways to format objects, these suffixes are used in the `prepare_params` function
	private static final ImmutableList<String> SUFFIXES =
	ImmutableList.of("_str", "_repr", "_format", "_str_perc", "_repr_perc");

	private Object skylarkLoadingEval(String code) throws Exception {
	return skylarkLoadingEval(code, "");
	}

	/**
	* Evaluates {@code code} in the loading phase in a .bzl file
	*
	* @param code The code to execute
	* @param definition Additional code to define necessary variables
	*/
	private Object skylarkLoadingEval(String code, String definition) throws Exception {
	scratch.overwriteFile("eval/BUILD", "load(':eval.bzl', 'eval')", "eval(name='eval')");
	scratch.overwriteFile(
	"eval/eval.bzl",
	definition,
	String.format("x = %s", code), // Should be placed here to execute during the loading phase
	"def _impl(ctx):",
	" return struct(result = x)",
	"eval = rule(implementation = _impl)");
	skyframeExecutor.invalidateFilesUnderPathForTesting(
	reporter,
	new ModifiedFileSet.Builder()
	.modify(PathFragment.create("eval/BUILD"))
	.modify(PathFragment.create("eval/eval.bzl"))
	.build(),
	rootDirectory);

	ConfiguredTarget target = getConfiguredTarget("//eval");
	return target.get("result");
	}

	/**
	* Asserts that all 5 different ways to convert an object to a string of {@code expression}
	* ({@code str}, {@code repr}, {@code '%s'}, {@code '%r'}, {@code '{}'.format} return the correct
	* {@code representation}. Not applicable for objects that have different {@code str} and {@code
	* repr} representations.
	*
	* @param definition optional definition required to evaluate the {@code expression}
	* @param expression the expression to evaluate a string representation of
	* @param representation desired string representation
	*/
	private void assertStringRepresentation(
	String definition, String expression, String representation) throws Exception {
	assertThat(skylarkLoadingEval(String.format("str(%s)", expression), definition))
	.isEqualTo(representation);
	assertThat(skylarkLoadingEval(String.format("repr(%s)", expression), definition))
	.isEqualTo(representation);
	assertThat(skylarkLoadingEval(String.format("'%%s' %% (%s,)", expression), definition))
	.isEqualTo(representation);
	assertThat(skylarkLoadingEval(String.format("'%%r' %% (%s,)", expression), definition))
	.isEqualTo(representation);
	assertThat(skylarkLoadingEval(String.format("'{}'.format(%s)", expression), definition))
	.isEqualTo(representation);
	}

	private void assertStringRepresentation(String expression, String representation)
	throws Exception {
	assertStringRepresentation("", expression, representation);
	}

	/**
	* Creates a set of BUILD and .bzl files that gathers objects of many different types available in
	* Skylark and creates their string representations by calling `str` and `repr` on them. The
	* strings are available in the configured target for //test/skylark:check
	*/
	private void generateFilesToTestStrings() throws Exception {
	// Generate string representations of different Skylark types. Objects are generated in
	// test/skylark/rules.bzl: the top-level objects dict contains objects
	// available during the loading phase, and _check_impl(ctx) returns objects that are available
	// during the analysis phase. prepare_params(objects) converts a list of objects to a list of
	// their string representations.

	scratch.file(
	"test/skylark/rules.bzl",
	"aspect_ctx_provider = provider()",
	"def prepare_params(objects):",
	" params = {}",
	" for k, v in objects.items():",
	" params[k + '_str'] = str(v)",
	" params[k + '_repr'] = repr(v)",
	" params[k + '_format'] = '{}'.format(v)",
	" params[k + '_str_perc'] = '%s' % (v,)",
	" params[k + '_repr_perc'] = '%r' % (v,)",
	" return params",
	"",
	"def _impl_aspect(target, ctx):",
	" return [aspect_ctx_provider(ctx = ctx)]",
	"my_aspect = aspect(implementation = _impl_aspect)",
	"",
	"def _impl(ctx): pass",
	"dep = rule(implementation = _impl)",
	"",
	"def _genfile_impl(ctx):",
	" ctx.file_action(output = ctx.outputs.my_output, content = 'foo')",
	"genfile = rule(",
	" implementation = _genfile_impl,",
	" outputs = {",
	" 'my_output': '%{name}.txt',",
	" },",
	")",
	"",
	"def _check_impl(ctx):",
	" objects = {",
	" 'target': ctx.attr.deps[0],",
	" 'alias_target': ctx.attr.deps[1],",
	" 'aspect_target': ctx.attr.asp_deps[0],",
	" 'input_target': ctx.attr.srcs[0],",
	" 'output_target': ctx.attr.srcs[1],",
	" 'rule_ctx': ctx,",
	" 'aspect_ctx': ctx.attr.asp_deps[0][aspect_ctx_provider].ctx,",
	" }",
	" return struct(**prepare_params(objects))",
	"check = rule(",
	" implementation = _check_impl,",
	" attrs = {",
	" 'deps': attr.label_list(),",
	" 'asp_deps': attr.label_list(aspects = [my_aspect]),",
	" 'srcs': attr.label_list(allow_files = True),",
	" },",
	")");

	scratch.file(
	"test/skylark/BUILD",
	"load(':rules.bzl', 'check', 'dep', 'genfile')",
	"",
	"dep(name = 'foo')",
	"dep(name = 'bar')",
	"alias(name = 'foobar', actual = ':foo')",
	"genfile(name = 'output')",
	"check(",
	" name = 'check',",
	" deps = [':foo', ':foobar'],",
	" asp_deps = [':bar'],",
	" srcs = ['input.txt', 'output.txt'],",
	")");
	}

	@Test
	public void testStringRepresentations_Strings() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

	assertThat(skylarkLoadingEval("str('foo')")).isEqualTo("foo");
	assertThat(skylarkLoadingEval("'%s' % 'foo'")).isEqualTo("foo");
	assertThat(skylarkLoadingEval("'{}'.format('foo')")).isEqualTo("foo");
	assertThat(skylarkLoadingEval("repr('foo')")).isEqualTo("\"foo\"");
	assertThat(skylarkLoadingEval("'%r' % 'foo'")).isEqualTo("\"foo\"");
	}

	@Test
	public void testStringRepresentations_Labels() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

	assertThat(skylarkLoadingEval("str(Label('//foo:bar'))")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("'%s' % Label('//foo:bar')")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("'{}'.format(Label('//foo:bar'))")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("repr(Label('//foo:bar'))")).isEqualTo("Label(\"//foo:bar\")");
	assertThat(skylarkLoadingEval("'%r' % Label('//foo:bar')")).isEqualTo("Label(\"//foo:bar\")");

	assertThat(skylarkLoadingEval("'{}'.format([Label('//foo:bar')])")).isEqualTo("[Label(\"//foo:bar\")]");
	}

	@Test
	public void testStringRepresentations_Primitives() throws Exception {
	// Strings are tested in a separate test case as they have different str and repr values.
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

	assertStringRepresentation("1543", "1543");
	assertStringRepresentation("True", "True");
	assertStringRepresentation("False", "False");
	}

	@Test
	public void testStringRepresentations_Containers() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=true");

	assertStringRepresentation("['a', 'b']", "[\"a\", \"b\"]");
	assertStringRepresentation("('a', 'b')", "(\"a\", \"b\")");
	assertStringRepresentation("{'a': 'b', 'c': 'd'}", "{\"a\": \"b\", \"c\": \"d\"}");
	assertStringRepresentation("struct(d = 4, c = 3)", "struct(c = 3, d = 4)");
	}

	@Test
	public void testLegacyStringRepresentations_Labels() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	assertThat(skylarkLoadingEval("str(Label('//foo:bar'))")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("'%s' % Label('//foo:bar')")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("'{}'.format(Label('//foo:bar'))")).isEqualTo("//foo:bar");
	assertThat(skylarkLoadingEval("repr(Label('//foo:bar'))")).isEqualTo("\"//foo:bar\"");
	assertThat(skylarkLoadingEval("'%r' % Label('//foo:bar')")).isEqualTo("\"//foo:bar\"");

	// Also test that str representations (as opposed to repr) also use legacy formatting
	// They are equivalent for labels, but not equivalent for lists of labels, because
	// containers always render their items with repr
	assertThat(skylarkLoadingEval("str([Label('//foo:bar')])")).isEqualTo("[\"//foo:bar\"]");
	assertThat(skylarkLoadingEval("'{}'.format([Label('//foo:bar')])")).isEqualTo("[\"//foo:bar\"]");
	assertThat(skylarkLoadingEval("'%s' % [Label('//foo:bar')]")).isEqualTo("[\"//foo:bar\"]");
	}

	@Test
	public void testLegacyStringRepresentations_Functions() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	assertStringRepresentation("all", "<function all>");
	assertStringRepresentation("def f(): pass", "f", "<function f>");
	}

	@Test
	public void testLegacyStringRepresentations_Rules() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	assertStringRepresentation("native.cc_library", "<function cc_library>");
	assertStringRepresentation("rule(implementation=str)", "<function rule>");
	assertStringRepresentation("aspect(implementation=str)", "Aspect:<function str>");
	}

	@Test
	public void testLegacyStringRepresentations_Providers() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	assertStringRepresentation("provider()", "<function <no name>>");
	assertStringRepresentation("p = provider()", "p(b = 2, a = 1)", "p(a = 1, b = 2)");
	}

	@Test
	public void testLegacyStringRepresentations_Select() throws Exception {
	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	assertStringRepresentation(
	"select({'//foo': ['//bar']}) + select({'//foo2': ['//bar2']})",
	"selector({\"//foo\": [\"//bar\"]}) + selector({\"//foo2\": [\"//bar2\"]})");
	}

	@Test
	public void testLegacyStringRepresentations_Targets() throws Exception {
	// alias targets in skylark used to leak their memory addresses in string representations,
	// we don't try to preserve this behaviour as it's harmful.
	// An example of their legacy representation:
	// "<com.google.devtools.build.lib.rules.AliasConfiguredTarget@12da9140>"

	setSkylarkSemanticsOptions("--incompatible_descriptive_string_representations=false");

	generateFilesToTestStrings();
	ConfiguredTarget target = getConfiguredTarget("//test/skylark:check");


	ImmutableList<Pair<String, String>> parameters = ImmutableList.of(
	new Pair<>("rule_ctx", "//test/skylark:check"),
	new Pair<>("aspect_ctx", "//test/skylark:bar"),
	new Pair<>("input_target", "InputFileConfiguredTarget(//test/skylark:input.txt)"));
	for (String suffix : SUFFIXES) {
	for (Pair<String, String > pair : parameters) {
	assertThat(target.get(pair.getFirst() + suffix)).isEqualTo(pair.getSecond());
	}
	}

	// Legacy representation of several types of objects may contain nondeterministic chunks
	parameters = ImmutableList.of(
	new Pair<>("target", "ConfiguredTarget\\(//test/skylark:foo, [0-9a-f]+\\)"),
	new Pair<>("aspect_target", "ConfiguredTarget\\(//test/skylark:bar, [0-9a-f]+\\)"),
	new Pair<>("output_target", "ConfiguredTarget\\(//test/skylark:output.txt, [0-9a-f]+\\)"));
	for (String suffix : SUFFIXES) {
	for (Pair<String, String > pair : parameters) {
	assertThat((String) target.get(pair.getFirst() + suffix)).matches(pair.getSecond());
	}
	}
	}
	}