src/test/java/com/google/devtools/build/lib/packages/AttributeContainerTest.java - bazel - Git at Google

 // Copyright 2015 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.packages;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.devtools.build.lib.packages.Attribute.attr;
 import static org.junit.Assert.assertThrows;

 import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
 import com.google.devtools.build.lib.analysis.util.MockRule;
 import com.google.devtools.build.lib.analysis.util.MockRuleDefaults;
 import com.google.devtools.build.lib.packages.Attribute.ComputedDefault;
 import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
 import com.google.testing.junit.testparameterinjector.TestParameter;
 import com.google.testing.junit.testparameterinjector.TestParameterInjector;
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.IntStream;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;

 /** Unit tests for {@link AttributeContainer}. */
 @RunWith(TestParameterInjector.class)
 public final class AttributeContainerTest extends BuildViewTestCase {

   private static final String STRING_DEFAULT = Type.STRING.getDefaultValue();
   private static final int COMPUTED_DEFAULT_OFFSET = 1;

   private enum ContainerSize {
     SMALL(16, AttributeContainer.Small.class),
     LARGE(128, AttributeContainer.Large.class);

     private final int numAttrs;
     private final Class<? extends AttributeContainer> expectedFrozenClass;

     ContainerSize(int numAttrs, Class<? extends AttributeContainer> expectedFrozenClass) {
       this.numAttrs = numAttrs;
       this.expectedFrozenClass = expectedFrozenClass;
     }
   }

   @TestParameter private ContainerSize containerSize;

   private Rule rule;
   private int firstCustomAttrIndex;
   private int lastCustomAttrIndex;
   private int computedDefaultIndex;

   private AttributeContainer container;

   @Override
   protected ConfiguredRuleClassProvider createRuleClassProvider() {
     int numDefaultAttrs = MockRuleDefaults.DEFAULT_ATTRIBUTES.size() + 1; // +1 for name.
     int numCustomAttrs = containerSize.numAttrs - numDefaultAttrs;
     MockRule exampleRule =
         () ->
             MockRule.define(
                 "example_rule",
                 IntStream.range(0, numCustomAttrs)
                     .mapToObj(
                         i -> {
                           var attr = attr("attr" + i, Type.STRING);
                           // Make one of the attributes a computed default.
                           if (i == COMPUTED_DEFAULT_OFFSET) {
                             attr.value(
                                 new ComputedDefault() {
                                   @Override
                                   public Object getDefault(AttributeMap rule) {
                                     return "computed";
                                   }
                                 });
                           }
                           return attr;
                         })
                     .toArray(Attribute.Builder[]::new));
     var builder = new ConfiguredRuleClassProvider.Builder().addRuleDefinition(exampleRule);
     TestRuleClassProvider.addStandardRules(builder);
     return builder.build();
   }

   @Before
   public void setUpForRule() throws Exception {
     scratch.file("foo/BUILD", "example_rule(name = 'example')");
     rule = (Rule) getTarget("//foo:example");
     firstCustomAttrIndex = rule.getRuleClassObject().getAttributeIndex("attr0");
     lastCustomAttrIndex = rule.getRuleClassObject().getAttributeCount() - 1;
     computedDefaultIndex = firstCustomAttrIndex + COMPUTED_DEFAULT_OFFSET;
     container = AttributeContainer.newMutableInstance(rule.getRuleClassObject());
   }

   @Test
   public void attributeSettingAndRetrieval(@TestParameter boolean frozen) {
     container.setAttributeValue(firstCustomAttrIndex, "val1", /* explicit= */ true);
     container.setAttributeValue(lastCustomAttrIndex, "val2", /* explicit= */ true);

     if (frozen) {
       container = container.freeze(rule);
     }

     assertThat(container.getAttributeValue(firstCustomAttrIndex)).isEqualTo("val1");
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
     assertThat(container.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
     assertThat(container.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isTrue();
   }

   @Test
   public void indexOutOfBounds_throws(@TestParameter boolean frozen) {
     if (frozen) {
       container = container.freeze(rule);
     }
     assertThrows(
         IndexOutOfBoundsException.class,
         () -> container.getAttributeValue(lastCustomAttrIndex + 1));
   }

   @Test
   public void testForOffByOneError(@TestParameter boolean frozen) {
     // Set an index explicitly and check neighbouring indices don't leak that.
     container.setAttributeValue(firstCustomAttrIndex, "val", true);

     if (frozen) {
       container = container.freeze(rule);
     }

     assertThat(container.getAttributeValue(firstCustomAttrIndex - 1)).isNull();
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex - 1)).isFalse();
     assertThat(container.getAttributeValue(firstCustomAttrIndex + 1)).isNull();
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex + 1)).isFalse();
   }

   @Test
   public void testFreezeWorks() {
     container.setAttributeValue(firstCustomAttrIndex, "val1", /* explicit= */ true);
     container.setAttributeValue(lastCustomAttrIndex, "val2", /* explicit= */ false);
     assertThat(container.isFrozen()).isFalse();

     AttributeContainer frozen = container.freeze(rule);

     assertThat(frozen.isFrozen()).isTrue();
     assertThat(frozen).isInstanceOf(containerSize.expectedFrozenClass);
     // freezing returned something else.
     assertThat(frozen).isNotSameInstanceAs(container);
     // Double freezing is a no-op
     assertThat(frozen.freeze(rule)).isSameInstanceAs(frozen);
     // reads/explicit bits work as expected
     assertThat(frozen.getAttributeValue(firstCustomAttrIndex)).isEqualTo("val1");
     assertThat(frozen.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
     assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
     assertThat(frozen.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isFalse();
     // writes no longer work.
     assertThrows(
         UnsupportedOperationException.class,
         () -> frozen.setAttributeValue(lastCustomAttrIndex, "different", true));
     // Updates to the original container no longer reflected in new container.
     container.setAttributeValue(lastCustomAttrIndex, "different", true);
     assertThat(container.getAttributeValue(lastCustomAttrIndex)).isEqualTo("different");
     assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
   }

   @Test
   public void fullContainer(@TestParameter boolean frozen) {
     int size = rule.getRuleClassObject().getAttributeCount();
     for (int i = 0; i < size; i++) {
       container.setAttributeValue(i, "value " + i, i % 2 == 0);
     }

     if (frozen) {
       container = container.freeze(rule);
     }

     for (int i = 0; i < size; i++) {
       assertThat(container.getAttributeValue(i)).isEqualTo("value " + i);
       assertWithMessage("attribute " + i)
           .that(container.isAttributeValueExplicitlySpecified(i))
           .isEqualTo(i % 2 == 0);
     }
   }

   @Test
   public void getRawAttributeValues_mutableContainer_returnsNullSafeCopy() {
     List<Object> rawValues = container.getRawAttributeValues();
     List<Object> expected =
         Collections.nCopies(rule.getRuleClassObject().getAttributeCount(), null);
     assertThat(rawValues).isEqualTo(expected);
     container.getRawAttributeValues().set(0, "foo");
     assertThat(container.getRawAttributeValues()).isEqualTo(expected);
   }

   @Test
   public void getRawAttributeValues_frozen_returnsCopyWithoutNulls() {
     container.setAttributeValue(firstCustomAttrIndex, "hi", /* explicit= */ true);
     container.setAttributeValue(lastCustomAttrIndex, null, /* explicit= */ false);

     container = container.freeze(rule);
     assertThat(container.getRawAttributeValues()).containsExactly("hi");

     container.getRawAttributeValues().set(0, "foo");
     assertThat(container.getRawAttributeValues()).containsExactly("hi");
   }

   /** Regression test for b/269593252. */
   @Test
   public void boundaryOfFrozenContainer() {
     container.setAttributeValue(0, "0", /* explicit= */ true);
     container.setAttributeValue(lastCustomAttrIndex, "last", /* explicit= */ true);

     AttributeContainer frozen = container.freeze(rule);

     assertThat(frozen.getAttributeValue(0)).isEqualTo("0");
     assertThat(frozen.isAttributeValueExplicitlySpecified(0)).isTrue();
     assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("last");
     assertThat(frozen.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isTrue();
   }

   @Test
   public void explictDefaultValue_stored(@TestParameter boolean frozen) {
     container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ true);

     if (frozen) {
       container = container.freeze(rule);
     }

     assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNotNull();
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
   }

   @Test
   public void nonExplicitDefaultValue_mutable_stored() {
     container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ false);

     assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNotNull();
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isFalse();
   }

   @Test
   public void nonExplicitDefaultValue_frozen_notStored() {
     container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ false);

     container = container.freeze(rule);

     assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNull();
     assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isFalse();
   }

   @Test
   public void computedDefault_mutable_stored() {
     Attribute attr = rule.getRuleClassObject().getAttribute(computedDefaultIndex);
     var computedDefault = attr.getDefaultValue(rule);
     assertThat(attr.hasComputedDefault()).isTrue();
     assertThat(computedDefault).isInstanceOf(ComputedDefault.class);

     container.setAttributeValue(computedDefaultIndex, computedDefault, /* explicit= */ false);

     assertThat(container.getAttributeValue(computedDefaultIndex)).isEqualTo(computedDefault);
     assertThat(container.isAttributeValueExplicitlySpecified(computedDefaultIndex)).isFalse();
   }

   @Test
   public void computedDefault_frozen_notStored() {
     Attribute attr = rule.getRuleClassObject().getAttribute(computedDefaultIndex);
     var computedDefault = attr.getDefaultValue(rule);
     assertThat(attr.hasComputedDefault()).isTrue();
     assertThat(computedDefault).isInstanceOf(ComputedDefault.class);

     container.setAttributeValue(computedDefaultIndex, computedDefault, /* explicit= */ false);
     container = container.freeze(rule);

     assertThat(container.getAttributeValue(computedDefaultIndex)).isNull();
     assertThat(container.isAttributeValueExplicitlySpecified(computedDefaultIndex)).isFalse();
   }
 }
	// Copyright 2015 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.packages;

	import static com.google.common.truth.Truth.assertThat;
	import static com.google.common.truth.Truth.assertWithMessage;
	import static com.google.devtools.build.lib.packages.Attribute.attr;
	import static org.junit.Assert.assertThrows;

	import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
	import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
	import com.google.devtools.build.lib.analysis.util.MockRule;
	import com.google.devtools.build.lib.analysis.util.MockRuleDefaults;
	import com.google.devtools.build.lib.packages.Attribute.ComputedDefault;
	import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
	import com.google.testing.junit.testparameterinjector.TestParameter;
	import com.google.testing.junit.testparameterinjector.TestParameterInjector;
	import java.util.Collections;
	import java.util.List;
	import java.util.stream.IntStream;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;

	/** Unit tests for {@link AttributeContainer}. */
	@RunWith(TestParameterInjector.class)
	public final class AttributeContainerTest extends BuildViewTestCase {

	private static final String STRING_DEFAULT = Type.STRING.getDefaultValue();
	private static final int COMPUTED_DEFAULT_OFFSET = 1;

	private enum ContainerSize {
	SMALL(16, AttributeContainer.Small.class),
	LARGE(128, AttributeContainer.Large.class);

	private final int numAttrs;
	private final Class<? extends AttributeContainer> expectedFrozenClass;

	ContainerSize(int numAttrs, Class<? extends AttributeContainer> expectedFrozenClass) {
	this.numAttrs = numAttrs;
	this.expectedFrozenClass = expectedFrozenClass;
	}
	}

	@TestParameter private ContainerSize containerSize;

	private Rule rule;
	private int firstCustomAttrIndex;
	private int lastCustomAttrIndex;
	private int computedDefaultIndex;

	private AttributeContainer container;

	@Override
	protected ConfiguredRuleClassProvider createRuleClassProvider() {
	int numDefaultAttrs = MockRuleDefaults.DEFAULT_ATTRIBUTES.size() + 1; // +1 for name.
	int numCustomAttrs = containerSize.numAttrs - numDefaultAttrs;
	MockRule exampleRule =
	() ->
	MockRule.define(
	"example_rule",
	IntStream.range(0, numCustomAttrs)
	.mapToObj(
	i -> {
	var attr = attr("attr" + i, Type.STRING);
	// Make one of the attributes a computed default.
	if (i == COMPUTED_DEFAULT_OFFSET) {
	attr.value(
	new ComputedDefault() {
	@Override
	public Object getDefault(AttributeMap rule) {
	return "computed";
	}
	});
	}
	return attr;
	})
	.toArray(Attribute.Builder[]::new));
	var builder = new ConfiguredRuleClassProvider.Builder().addRuleDefinition(exampleRule);
	TestRuleClassProvider.addStandardRules(builder);
	return builder.build();
	}

	@Before
	public void setUpForRule() throws Exception {
	scratch.file("foo/BUILD", "example_rule(name = 'example')");
	rule = (Rule) getTarget("//foo:example");
	firstCustomAttrIndex = rule.getRuleClassObject().getAttributeIndex("attr0");
	lastCustomAttrIndex = rule.getRuleClassObject().getAttributeCount() - 1;
	computedDefaultIndex = firstCustomAttrIndex + COMPUTED_DEFAULT_OFFSET;
	container = AttributeContainer.newMutableInstance(rule.getRuleClassObject());
	}

	@Test
	public void attributeSettingAndRetrieval(@TestParameter boolean frozen) {
	container.setAttributeValue(firstCustomAttrIndex, "val1", /* explicit= */ true);
	container.setAttributeValue(lastCustomAttrIndex, "val2", /* explicit= */ true);

	if (frozen) {
	container = container.freeze(rule);
	}

	assertThat(container.getAttributeValue(firstCustomAttrIndex)).isEqualTo("val1");
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
	assertThat(container.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
	assertThat(container.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isTrue();
	}

	@Test
	public void indexOutOfBounds_throws(@TestParameter boolean frozen) {
	if (frozen) {
	container = container.freeze(rule);
	}
	assertThrows(
	IndexOutOfBoundsException.class,
	() -> container.getAttributeValue(lastCustomAttrIndex + 1));
	}

	@Test
	public void testForOffByOneError(@TestParameter boolean frozen) {
	// Set an index explicitly and check neighbouring indices don't leak that.
	container.setAttributeValue(firstCustomAttrIndex, "val", true);

	if (frozen) {
	container = container.freeze(rule);
	}

	assertThat(container.getAttributeValue(firstCustomAttrIndex - 1)).isNull();
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex - 1)).isFalse();
	assertThat(container.getAttributeValue(firstCustomAttrIndex + 1)).isNull();
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex + 1)).isFalse();
	}

	@Test
	public void testFreezeWorks() {
	container.setAttributeValue(firstCustomAttrIndex, "val1", /* explicit= */ true);
	container.setAttributeValue(lastCustomAttrIndex, "val2", /* explicit= */ false);
	assertThat(container.isFrozen()).isFalse();

	AttributeContainer frozen = container.freeze(rule);

	assertThat(frozen.isFrozen()).isTrue();
	assertThat(frozen).isInstanceOf(containerSize.expectedFrozenClass);
	// freezing returned something else.
	assertThat(frozen).isNotSameInstanceAs(container);
	// Double freezing is a no-op
	assertThat(frozen.freeze(rule)).isSameInstanceAs(frozen);
	// reads/explicit bits work as expected
	assertThat(frozen.getAttributeValue(firstCustomAttrIndex)).isEqualTo("val1");
	assertThat(frozen.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
	assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
	assertThat(frozen.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isFalse();
	// writes no longer work.
	assertThrows(
	UnsupportedOperationException.class,
	() -> frozen.setAttributeValue(lastCustomAttrIndex, "different", true));
	// Updates to the original container no longer reflected in new container.
	container.setAttributeValue(lastCustomAttrIndex, "different", true);
	assertThat(container.getAttributeValue(lastCustomAttrIndex)).isEqualTo("different");
	assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("val2");
	}

	@Test
	public void fullContainer(@TestParameter boolean frozen) {
	int size = rule.getRuleClassObject().getAttributeCount();
	for (int i = 0; i < size; i++) {
	container.setAttributeValue(i, "value " + i, i % 2 == 0);
	}

	if (frozen) {
	container = container.freeze(rule);
	}

	for (int i = 0; i < size; i++) {
	assertThat(container.getAttributeValue(i)).isEqualTo("value " + i);
	assertWithMessage("attribute " + i)
	.that(container.isAttributeValueExplicitlySpecified(i))
	.isEqualTo(i % 2 == 0);
	}
	}

	@Test
	public void getRawAttributeValues_mutableContainer_returnsNullSafeCopy() {
	List<Object> rawValues = container.getRawAttributeValues();
	List<Object> expected =
	Collections.nCopies(rule.getRuleClassObject().getAttributeCount(), null);
	assertThat(rawValues).isEqualTo(expected);
	container.getRawAttributeValues().set(0, "foo");
	assertThat(container.getRawAttributeValues()).isEqualTo(expected);
	}

	@Test
	public void getRawAttributeValues_frozen_returnsCopyWithoutNulls() {
	container.setAttributeValue(firstCustomAttrIndex, "hi", /* explicit= */ true);
	container.setAttributeValue(lastCustomAttrIndex, null, /* explicit= */ false);

	container = container.freeze(rule);
	assertThat(container.getRawAttributeValues()).containsExactly("hi");

	container.getRawAttributeValues().set(0, "foo");
	assertThat(container.getRawAttributeValues()).containsExactly("hi");
	}

	/** Regression test for b/269593252. */
	@Test
	public void boundaryOfFrozenContainer() {
	container.setAttributeValue(0, "0", /* explicit= */ true);
	container.setAttributeValue(lastCustomAttrIndex, "last", /* explicit= */ true);

	AttributeContainer frozen = container.freeze(rule);

	assertThat(frozen.getAttributeValue(0)).isEqualTo("0");
	assertThat(frozen.isAttributeValueExplicitlySpecified(0)).isTrue();
	assertThat(frozen.getAttributeValue(lastCustomAttrIndex)).isEqualTo("last");
	assertThat(frozen.isAttributeValueExplicitlySpecified(lastCustomAttrIndex)).isTrue();
	}

	@Test
	public void explictDefaultValue_stored(@TestParameter boolean frozen) {
	container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ true);

	if (frozen) {
	container = container.freeze(rule);
	}

	assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNotNull();
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isTrue();
	}

	@Test
	public void nonExplicitDefaultValue_mutable_stored() {
	container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ false);

	assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNotNull();
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isFalse();
	}

	@Test
	public void nonExplicitDefaultValue_frozen_notStored() {
	container.setAttributeValue(firstCustomAttrIndex, STRING_DEFAULT, /* explicit= */ false);

	container = container.freeze(rule);

	assertThat(container.getAttributeValue(firstCustomAttrIndex)).isNull();
	assertThat(container.isAttributeValueExplicitlySpecified(firstCustomAttrIndex)).isFalse();
	}

	@Test
	public void computedDefault_mutable_stored() {
	Attribute attr = rule.getRuleClassObject().getAttribute(computedDefaultIndex);
	var computedDefault = attr.getDefaultValue(rule);
	assertThat(attr.hasComputedDefault()).isTrue();
	assertThat(computedDefault).isInstanceOf(ComputedDefault.class);

	container.setAttributeValue(computedDefaultIndex, computedDefault, /* explicit= */ false);

	assertThat(container.getAttributeValue(computedDefaultIndex)).isEqualTo(computedDefault);
	assertThat(container.isAttributeValueExplicitlySpecified(computedDefaultIndex)).isFalse();
	}

	@Test
	public void computedDefault_frozen_notStored() {
	Attribute attr = rule.getRuleClassObject().getAttribute(computedDefaultIndex);
	var computedDefault = attr.getDefaultValue(rule);
	assertThat(attr.hasComputedDefault()).isTrue();
	assertThat(computedDefault).isInstanceOf(ComputedDefault.class);

	container.setAttributeValue(computedDefaultIndex, computedDefault, /* explicit= */ false);
	container = container.freeze(rule);

	assertThat(container.getAttributeValue(computedDefaultIndex)).isNull();
	assertThat(container.isAttributeValueExplicitlySpecified(computedDefaultIndex)).isFalse();
	}
	}