BEGIN_PUBLIC
starlark: infinite precision ints
BEWARE: j.l.Integer is no longer a legal Starlark value.
This change makes the Starlark 'int' type a bigint,
aka infinite-precision integer, one capable of exact arithmetic
on any integer value. The new Int class has three subclasses,
similar to j.l.Integer, j.l.Long, and j.l.BigInteger.
The most compact representation is always used.
This makes Starlark capable of handling all the integer
types that occur in protocol messages---signed and unsigned
64-bit values.
Memory usage should not change much because StarlarkInt.Int32
has the same layout as the j.l.Integer it replaces.
As with j.l.Integer, small values (<100,000) are cached
to avoid unnecessary allocation.
Integer is no longer a legal Starlark value type. However,
for compatibility and convenience, parameters of
StarlarkMethod-annotated Java functions may continue to
use Integer to mean "32-bit signed int". The interpreter
does a "reboxing" operation to convert Int arguments
to Integer parameters as needed. Also, such functions may
return Integer values, and they will be reboxed by fromJava,
similar to List and Map. However, just as one cannot return
List and Map values nested inside Starlark data structures,
nor can one nest Integers in them; an explicit boxing operation
is required: StarlarkInt.of(x).
To limit the scope of this change, it does not yet add support
for parsing bigint literals. That will come in a follow-up.
Bazel: attr.int(..) rule attributes now use Int instead of
Integer. This is necessary because the assumption that Attribute
values are all legal Starlark values seems to be widely relied on.
However, int attributes remain restricted to the signed 32-bit
part of the value range. (Changing this would have much greater
ramifications for Bazel.) Every access of an int-valued rule
attribute must now call toIntUnchecked(), which cannot fail.
Suggested reading order:
- eval.StarlarkInt, the new type.
- the rest of eval, which does reboxing.
- trivial updates to tests of the interpreter.
(Most of these tests belong in testdata/*.star files.)
- lib.packages attribute changes.
- the rest, which is mostly trivial updates.
The most obvious downsides of this change are the loss of implicit
boxing, the potential for latent errors due to the lack of dynamic
checkValid calls in (e.g.) Dict.put, and the need to tell other Java
packages (such as the Gson JSON package) that Int is basically a
version of Integer, which it already knows about.
I have no doubt missed a few spots, and we may encounter a few
unhelpful "want int, got int" errors when an Integer value
sneaks into the Starlark value realm. I will fix them as they
arise.
Credit to Jon Brandvein for b/36358845#comment9. Before it, I
had resigned myself to this feature being infeasible in Starlark/Java.
END_PUBLIC
PiperOrigin-RevId: 334649352
diff --git a/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java b/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
index c5a5667..76bb485 100644
--- a/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
+++ b/src/test/java/com/google/devtools/build/docgen/RuleDocumentationAttributeTest.java
@@ -23,6 +23,7 @@
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.Type;
import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -116,7 +117,7 @@
@Test
public void testSynopsisForIntegerAttribute() {
- final int defaultValue = 384;
+ StarlarkInt defaultValue = StarlarkInt.of(384);
Attribute attribute = Attribute.attr("bar_limit", Type.INTEGER)
.value(defaultValue).build();
RuleDocumentationAttribute attributeDoc = RuleDocumentationAttribute.create(
diff --git a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
index fce6873..70aa7e0 100644
--- a/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/analysis/StarlarkAttrTransitionProviderTest.java
@@ -46,6 +46,7 @@
import java.util.stream.Collectors;
import net.starlark.java.eval.Dict;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -1050,7 +1051,7 @@
.getOptions()
.getStarlarkOptions()
.get(Label.parseAbsoluteUnchecked("//test/starlark:the-answer")))
- .isEqualTo(42);
+ .isEqualTo(StarlarkInt.of(42));
}
@Test
@@ -1084,7 +1085,7 @@
.getOptions()
.getStarlarkOptions()
.get(Label.parseAbsoluteUnchecked("//test/starlark:the-answer")))
- .isEqualTo(42);
+ .isEqualTo(StarlarkInt.of(42));
}
private CoreOptions getCoreOptions(ConfiguredTarget target) {
diff --git a/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java b/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
index 5ef6a39..9eacd9e 100644
--- a/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
+++ b/src/test/java/com/google/devtools/build/lib/collect/nestedset/DepsetTest.java
@@ -22,6 +22,7 @@
import net.starlark.java.eval.Dict;
import net.starlark.java.eval.Sequence;
import net.starlark.java.eval.StarlarkCallable;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkIterable;
import net.starlark.java.eval.StarlarkList;
import net.starlark.java.eval.StarlarkValue;
@@ -68,7 +69,10 @@
Tuple.of("1", "3", "5"), Tuple.of("1", "2"), Tuple.of("3", "4"), Tuple.of("5", "6"));
assertThat(get("s_eight").getSet(Tuple.class).toList())
.containsExactly(
- Tuple.of(1, 3), Tuple.of("1", "2"), Tuple.of("3", "4"), Tuple.of("5", "6"));
+ Tuple.of(StarlarkInt.of(1), StarlarkInt.of(3)),
+ Tuple.of("1", "2"),
+ Tuple.of("3", "4"),
+ Tuple.of("5", "6"));
}
@Test
@@ -76,12 +80,14 @@
ev.exec("s = depset(['a', 'b'])");
assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
// getSet argument must be a legal Starlark value class, or Object,
// but not some superclass that doesn't implement StarlarkValue.
- Depset ints = Depset.legacyOf(Order.STABLE_ORDER, Tuple.of(1, 2, 3));
- assertThat(ints.getSet(Integer.class).toString()).isEqualTo("[1, 2, 3]");
+ Depset ints =
+ Depset.legacyOf(
+ Order.STABLE_ORDER, Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
+ assertThat(ints.getSet(StarlarkInt.class).toString()).isEqualTo("[1, 2, 3]");
IllegalArgumentException ex =
assertThrows(IllegalArgumentException.class, () -> ints.getSet(Number.class));
assertThat(ex.getMessage()).contains("Number is not a subclass of StarlarkValue");
@@ -92,7 +98,7 @@
ev.exec("s = depset(direct = ['a', 'b'])");
assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
}
@Test
@@ -100,7 +106,7 @@
ev.exec("s = depset(items = ['a', 'b'])");
assertThat(get("s").getSet(String.class).toList()).containsExactly("a", "b").inOrder();
assertThat(get("s").getSet(Object.class).toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").getSet(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").getSet(StarlarkInt.class));
}
@Test
@@ -109,7 +115,7 @@
assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
}
@Test
@@ -118,7 +124,7 @@
assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
}
@Test
@@ -127,7 +133,7 @@
assertThat(get("s").toList(String.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList(Object.class)).containsExactly("a", "b").inOrder();
assertThat(get("s").toList()).containsExactly("a", "b").inOrder();
- assertThrows(Depset.TypeException.class, () -> get("s").toList(Integer.class));
+ assertThrows(Depset.TypeException.class, () -> get("s").toList(StarlarkInt.class));
}
@Test
@@ -322,10 +328,11 @@
@Test
public void testToListForStarlark() throws Exception {
- ev.exec("s = depset([3, 4, 5], transitive = [depset([2, 4, 6])])", "x = s.to_list()");
- Object value = ev.lookup("x");
- assertThat(value).isInstanceOf(StarlarkList.class);
- assertThat((Iterable<?>) value).containsExactly(2, 4, 6, 3, 5).inOrder();
+ ev.exec(
+ "s = depset([3, 4, 5], transitive = [depset([2, 4, 6])])",
+ "x = s.to_list()",
+ "y = [2, 4, 6, 3, 5]");
+ assertThat(ev.lookup("x")).isEqualTo(ev.lookup("y"));
}
@Test
@@ -469,7 +476,7 @@
public void testElementTypeOf() {
// legal values
assertThat(ElementType.of(String.class).toString()).isEqualTo("string");
- assertThat(ElementType.of(Integer.class).toString()).isEqualTo("int");
+ assertThat(ElementType.of(StarlarkInt.class).toString()).isEqualTo("int");
assertThat(ElementType.of(Boolean.class).toString()).isEqualTo("bool");
// concrete non-values
diff --git a/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java b/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
index 998a9fe..75b4d8e 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/AttributeTest.java
@@ -42,6 +42,7 @@
import java.util.Collections;
import java.util.List;
import java.util.Map;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -60,9 +61,9 @@
@Test
public void testBasics() throws Exception {
- Attribute attr = attr("foo", Type.INTEGER).mandatory().value(3).build();
+ Attribute attr = attr("foo", Type.INTEGER).mandatory().value(StarlarkInt.of(3)).build();
assertThat(attr.getName()).isEqualTo("foo");
- assertThat(attr.getDefaultValue(null)).isEqualTo(3);
+ assertThat(attr.getDefaultValue(null)).isEqualTo(StarlarkInt.of(3));
assertThat(attr.getType()).isEqualTo(Type.INTEGER);
assertThat(attr.isMandatory()).isTrue();
assertThat(attr.isDocumented()).isTrue();
@@ -75,7 +76,7 @@
NullPointerException e =
assertThrows(
NullPointerException.class,
- () -> attr("foo", Type.INTEGER).nonEmpty().value(3).build());
+ () -> attr("foo", Type.INTEGER).nonEmpty().value(StarlarkInt.of(3)).build());
assertThat(e).hasMessageThat().isEqualTo("attribute 'foo' must be a list");
}
@@ -92,7 +93,7 @@
IllegalStateException e =
assertThrows(
IllegalStateException.class,
- () -> attr("foo", Type.INTEGER).singleArtifact().value(3).build());
+ () -> attr("foo", Type.INTEGER).singleArtifact().value(StarlarkInt.of(3)).build());
assertThat(e).hasMessageThat().isEqualTo("attribute 'foo' must be a label-valued type");
}
@@ -119,10 +120,8 @@
*/
@Test
public void testConvenienceFactoriesDefaultValues() throws Exception {
- assertDefaultValue(0,
- attr("x", INTEGER).build());
- assertDefaultValue(42,
- attr("x", INTEGER).value(42).build());
+ assertDefaultValue(StarlarkInt.of(0), attr("x", INTEGER).build());
+ assertDefaultValue(StarlarkInt.of(42), attr("x", INTEGER).value(StarlarkInt.of(42)).build());
assertDefaultValue("",
attr("x", STRING).build());
@@ -158,8 +157,7 @@
public void testConvenienceFactoriesTypes() throws Exception {
assertType(INTEGER,
attr("x", INTEGER).build());
- assertType(INTEGER,
- attr("x", INTEGER).value(42).build());
+ assertType(INTEGER, attr("x", INTEGER).value(StarlarkInt.of(42)).build());
assertType(STRING,
attr("x", STRING).build());
diff --git a/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java b/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
index ad4c470..73e303c 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/RuleClassBuilderTest.java
@@ -30,6 +30,7 @@
import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassNamePredicate;
import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassType;
import com.google.devtools.build.lib.packages.util.PackageLoadingTestCase;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -82,7 +83,7 @@
.add(attr("size", STRING).value("medium"))
.add(attr("timeout", STRING))
.add(attr("flaky", BOOLEAN).value(false))
- .add(attr("shard_count", INTEGER).value(-1))
+ .add(attr("shard_count", INTEGER).value(StarlarkInt.of(-1)))
.add(attr("local", BOOLEAN))
.build();
assertThat(ruleClassA.hasBinaryOutput()).isTrue();
diff --git a/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java b/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
index 1e7ee19..4512457 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/RuleClassTest.java
@@ -68,6 +68,7 @@
import java.util.Set;
import javax.annotation.Nullable;
import net.starlark.java.eval.StarlarkFunction;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.syntax.Location;
@@ -129,7 +130,7 @@
.value(Label.parseAbsolute("//default:label", ImmutableMap.of()))
.build(),
attr("my-labellist-attr", LABEL_LIST).mandatory().legacyAllowAnyFileType().build(),
- attr("my-integer-attr", INTEGER).value(42).build(),
+ attr("my-integer-attr", INTEGER).value(StarlarkInt.of(42)).build(),
attr("my-string-attr2", STRING).mandatory().value((String) null).build(),
attr("my-stringlist-attr", STRING_LIST).build(),
attr("my-sorted-stringlist-attr", STRING_LIST).orderIndependent().build());
@@ -194,7 +195,7 @@
assertThat(ruleClassA.getAttribute(1).getDefaultValue(null))
.isEqualTo(Label.parseAbsolute("//default:label", ImmutableMap.of()));
assertThat(ruleClassA.getAttribute(2).getDefaultValue(null)).isEqualTo(Collections.emptyList());
- assertThat(ruleClassA.getAttribute(3).getDefaultValue(null)).isEqualTo(42);
+ assertThat(ruleClassA.getAttribute(3).getDefaultValue(null)).isEqualTo(StarlarkInt.of(42));
// default explicitly specified
assertThat(ruleClassA.getAttribute(4).getDefaultValue(null)).isNull();
assertThat(ruleClassA.getAttribute(5).getDefaultValue(null)).isEqualTo(Collections.emptyList());
@@ -386,7 +387,7 @@
AttributeMap attributes = RawAttributeMapper.of(rule);
assertThat(attributes.get("my-label-attr", BuildType.LABEL).toString())
.isEqualTo("//default:label");
- assertThat(attributes.get("my-integer-attr", Type.INTEGER).intValue()).isEqualTo(42);
+ assertThat(attributes.get("my-integer-attr", Type.INTEGER).toIntUnchecked()).isEqualTo(42);
// missing attribute -> default chosen based on type
assertThat(attributes.get("my-string-attr", Type.STRING)).isEmpty();
assertThat(attributes.get("my-labellist-attr", BuildType.LABEL_LIST)).isEmpty();
diff --git a/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java b/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
index 418b75a..3bcd5ad 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/SelectTest.java
@@ -22,6 +22,7 @@
import net.starlark.java.eval.Module;
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.syntax.FileOptions;
@@ -55,7 +56,7 @@
public void testSelect() throws Exception {
SelectorList result = (SelectorList) eval("select({'a': 1})");
assertThat(((SelectorValue) Iterables.getOnlyElement(result.getElements())).getDictionary())
- .containsExactly("a", 1);
+ .containsExactly("a", StarlarkInt.of(1));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java b/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
index d3595bd..cb34612 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/StarlarkInfoTest.java
@@ -26,6 +26,7 @@
import java.util.Random;
import javax.annotation.Nullable;
import net.starlark.java.eval.EvalException;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkValue;
import net.starlark.java.syntax.Location;
import net.starlark.java.syntax.TokenKind;
@@ -46,14 +47,14 @@
@Test
public void instancesOfUnexportedProvidersAreMutable() throws Exception {
StarlarkProvider provider = makeProvider();
- StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, null);
+ StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), null);
assertThat(info.isImmutable()).isFalse();
}
@Test
public void instancesOfExportedProvidersMayBeImmutable() throws Exception {
StarlarkProvider provider = makeExportedProvider();
- StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, null);
+ StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), null);
assertThat(info.isImmutable()).isTrue();
}
@@ -61,7 +62,7 @@
public void mutableIfContentsAreMutable() throws Exception {
StarlarkProvider provider = makeExportedProvider();
StarlarkValue v = new StarlarkValue() {};
- StarlarkInfo info = makeInfoWithF1F2Values(provider, 5, v);
+ StarlarkInfo info = makeInfoWithF1F2Values(provider, StarlarkInt.of(5), v);
assertThat(info.isImmutable()).isFalse();
}
@@ -70,25 +71,25 @@
StarlarkProvider provider1 = makeProvider();
StarlarkProvider provider2 = makeProvider();
// equal providers and fields
- assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
- .isEqualTo(makeInfoWithF1F2Values(provider1, 4, 5));
+ assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+ .isEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)));
// different providers => unequal
- assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
- .isNotEqualTo(makeInfoWithF1F2Values(provider2, 4, 5));
+ assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+ .isNotEqualTo(makeInfoWithF1F2Values(provider2, StarlarkInt.of(4), StarlarkInt.of(5)));
// different fields => unequal
- assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
- .isNotEqualTo(makeInfoWithF1F2Values(provider1, 4, 6));
+ assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+ .isNotEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(6)));
// different sets of fields => unequal
- assertThat(makeInfoWithF1F2Values(provider1, 4, 5))
- .isNotEqualTo(makeInfoWithF1F2Values(provider1, 4, null));
+ assertThat(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5)))
+ .isNotEqualTo(makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), null));
}
@Test
public void concatWithDifferentProvidersFails() throws Exception {
StarlarkProvider provider1 = makeProvider();
StarlarkProvider provider2 = makeProvider();
- StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, 4, 5);
- StarlarkInfo info2 = makeInfoWithF1F2Values(provider2, 4, 5);
+ StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5));
+ StarlarkInfo info2 = makeInfoWithF1F2Values(provider2, StarlarkInt.of(4), StarlarkInt.of(5));
EvalException expected =
assertThrows(EvalException.class, () -> info1.binaryOp(TokenKind.PLUS, info2, true));
assertThat(expected).hasMessageThat()
@@ -98,8 +99,8 @@
@Test
public void concatWithOverlappingFieldsFails() throws Exception {
StarlarkProvider provider1 = makeProvider();
- StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, 4, 5);
- StarlarkInfo info2 = makeInfoWithF1F2Values(provider1, 4, null);
+ StarlarkInfo info1 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), StarlarkInt.of(5));
+ StarlarkInfo info2 = makeInfoWithF1F2Values(provider1, StarlarkInt.of(4), null);
EvalException expected =
assertThrows(EvalException.class, () -> info1.binaryOp(TokenKind.PLUS, info2, true));
assertThat(expected)
@@ -110,23 +111,23 @@
@Test
public void concatWithSameFields() throws Exception {
StarlarkProvider provider = makeProvider();
- StarlarkInfo info1 = makeInfoWithF1F2Values(provider, 4, null);
- StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, 5);
+ StarlarkInfo info1 = makeInfoWithF1F2Values(provider, StarlarkInt.of(4), null);
+ StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, StarlarkInt.of(5));
StarlarkInfo result = info1.binaryOp(TokenKind.PLUS, info2, true);
assertThat(result.getFieldNames()).containsExactly("f1", "f2");
- assertThat(result.getValue("f1")).isEqualTo(4);
- assertThat(result.getValue("f2")).isEqualTo(5);
+ assertThat(result.getValue("f1")).isEqualTo(StarlarkInt.of(4));
+ assertThat(result.getValue("f2")).isEqualTo(StarlarkInt.of(5));
}
@Test
public void concatWithDifferentFields() throws Exception {
StarlarkProvider provider = makeProvider();
- StarlarkInfo info1 = makeInfoWithF1F2Values(provider, 4, null);
- StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, 5);
+ StarlarkInfo info1 = makeInfoWithF1F2Values(provider, StarlarkInt.of(4), null);
+ StarlarkInfo info2 = makeInfoWithF1F2Values(provider, null, StarlarkInt.of(5));
StarlarkInfo result = info1.binaryOp(TokenKind.PLUS, info2, true);
assertThat(result.getFieldNames()).containsExactly("f1", "f2");
- assertThat(result.getValue("f1")).isEqualTo(4);
- assertThat(result.getValue("f2")).isEqualTo(5);
+ assertThat(result.getValue("f1")).isEqualTo(StarlarkInt.of(4));
+ assertThat(result.getValue("f2")).isEqualTo(StarlarkInt.of(5));
}
/** Creates an unexported schemaless provider type with builtin location. */
diff --git a/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java b/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
index 7265c0d..776e183 100644
--- a/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
+++ b/src/test/java/com/google/devtools/build/lib/packages/TypeTest.java
@@ -28,6 +28,7 @@
import java.util.Arrays;
import java.util.List;
import java.util.Map;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkList;
import net.starlark.java.eval.Tuple;
import org.junit.Before;
@@ -50,9 +51,27 @@
@Test
public void testInteger() throws Exception {
- Object x = 3;
+ Object x = StarlarkInt.of(3);
assertThat(Type.INTEGER.convert(x, null)).isEqualTo(x);
assertThat(collectLabels(Type.INTEGER, x)).isEmpty();
+
+ // INTEGER rule attributes must be in signed 32-bit value range.
+ // (If we ever relax this, we'll need to audit every place that
+ // converts an attribute to an int using toIntUnchecked, since
+ // that operation might then fail, and extend the Package
+ // serialization protocol to support bigint.)
+ StarlarkInt big = StarlarkInt.of(111111111);
+ Type.ConversionException e =
+ assertThrows(
+ Type.ConversionException.class,
+ () -> Type.INTEGER.convert(StarlarkInt.multiply(big, big), "param"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("for param, got 12345678987654321, want value in signed 32-bit range");
+
+ // Ensure that the range of INTEGER.concat is int32.
+ assertThat(Type.INTEGER.concat(Arrays.asList(StarlarkInt.of(0x7fffffff), StarlarkInt.of(1))))
+ .isEqualTo(StarlarkInt.of(-0x80000000));
}
@Test
@@ -96,8 +115,8 @@
public void testBoolean() throws Exception {
Object myTrue = true;
Object myFalse = false;
- assertThat(Type.BOOLEAN.convert(1, null)).isEqualTo(Boolean.TRUE);
- assertThat(Type.BOOLEAN.convert(0, null)).isEqualTo(Boolean.FALSE);
+ assertThat(Type.BOOLEAN.convert(StarlarkInt.of(1), null)).isEqualTo(Boolean.TRUE);
+ assertThat(Type.BOOLEAN.convert(StarlarkInt.of(0), null)).isEqualTo(Boolean.FALSE);
assertThat(Type.BOOLEAN.convert(true, null)).isTrue();
assertThat(Type.BOOLEAN.convert(myTrue, null)).isTrue();
assertThat(Type.BOOLEAN.convert(false, null)).isFalse();
@@ -114,17 +133,21 @@
.hasMessageThat()
.isEqualTo("expected value of type 'int', but got \"unexpected\" (string)");
// Integers other than [0, 1] should fail.
- e = assertThrows(Type.ConversionException.class, () -> Type.BOOLEAN.convert(2, null));
+ e =
+ assertThrows(
+ Type.ConversionException.class, () -> Type.BOOLEAN.convert(StarlarkInt.of(2), null));
assertThat(e).hasMessageThat().isEqualTo("boolean is not one of [0, 1]");
- e = assertThrows(Type.ConversionException.class, () -> Type.BOOLEAN.convert(-1, null));
+ e =
+ assertThrows(
+ Type.ConversionException.class, () -> Type.BOOLEAN.convert(StarlarkInt.of(-1), null));
assertThat(e).hasMessageThat().isEqualTo("boolean is not one of [0, 1]");
}
@Test
public void testTriState() throws Exception {
- assertThat(BuildType.TRISTATE.convert(1, null)).isEqualTo(TriState.YES);
- assertThat(BuildType.TRISTATE.convert(0, null)).isEqualTo(TriState.NO);
- assertThat(BuildType.TRISTATE.convert(-1, null)).isEqualTo(TriState.AUTO);
+ assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(1), null)).isEqualTo(TriState.YES);
+ assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(0), null)).isEqualTo(TriState.NO);
+ assertThat(BuildType.TRISTATE.convert(StarlarkInt.of(-1), null)).isEqualTo(TriState.AUTO);
assertThat(BuildType.TRISTATE.convert(TriState.YES, null)).isEqualTo(TriState.YES);
assertThat(BuildType.TRISTATE.convert(TriState.NO, null)).isEqualTo(TriState.NO);
assertThat(BuildType.TRISTATE.convert(TriState.AUTO, null)).isEqualTo(TriState.AUTO);
@@ -137,9 +160,10 @@
@Test
public void testTriStateDoesNotAcceptArbitraryIntegers() throws Exception {
- List<Integer> listOfCases = Lists.newArrayList(2, 3, -5, -2, 20);
- for (Object entry : listOfCases) {
- assertThrows(Type.ConversionException.class, () -> BuildType.TRISTATE.convert(entry, null));
+ for (Integer i : Lists.newArrayList(2, 3, -5, -2, 20)) {
+ assertThrows(
+ Type.ConversionException.class,
+ () -> BuildType.TRISTATE.convert(StarlarkInt.of(i), null));
}
}
diff --git a/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java b/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
index 7991337..acee66b 100644
--- a/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
+++ b/src/test/java/com/google/devtools/build/lib/profiler/memory/AllocationTrackerTest.java
@@ -37,6 +37,7 @@
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Starlark;
import net.starlark.java.eval.StarlarkCallable;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkSemantics;
import net.starlark.java.eval.StarlarkThread;
import net.starlark.java.syntax.FileOptions;
@@ -64,8 +65,8 @@
private class SamplerValue implements HasBinary {
@Override
public Object binaryOp(TokenKind op, Object that, boolean thisLeft) throws EvalException {
- if (op == TokenKind.PLUS && thisLeft && that instanceof Integer) {
- int size = (Integer) that;
+ if (op == TokenKind.PLUS && thisLeft && that instanceof StarlarkInt) {
+ int size = ((StarlarkInt) that).toIntUnchecked(); // test values are small
Object obj = new Object();
live.add(obj); // ensure that obj outlives the test assertions
tracker.sampleAllocation(1, "", obj, size);
diff --git a/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java b/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
index 7e50d69..9a3a906 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/python/PyStructUtilsTest.java
@@ -33,6 +33,7 @@
import java.util.LinkedHashMap;
import java.util.Map;
import net.starlark.java.eval.EvalException;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Before;
import org.junit.Test;
import org.junit.function.ThrowingRunnable;
@@ -120,7 +121,8 @@
@Test
public void getTransitiveSources_WrongType() {
- StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.TRANSITIVE_SOURCES, 123));
+ StructImpl info =
+ makeStruct(ImmutableMap.of(PyStructUtils.TRANSITIVE_SOURCES, StarlarkInt.of(123)));
assertThrowsEvalExceptionContaining(
() -> PyStructUtils.getTransitiveSources(info),
"for transitive_sources, got int, want a depset of File");
@@ -151,7 +153,8 @@
@Test
public void getUsesSharedLibraries_WrongType() {
- StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.USES_SHARED_LIBRARIES, 123));
+ StructImpl info =
+ makeStruct(ImmutableMap.of(PyStructUtils.USES_SHARED_LIBRARIES, StarlarkInt.of(123)));
assertHasWrongTypeMessage(
() -> PyStructUtils.getUsesSharedLibraries(info), "uses_shared_libraries", "bool");
}
@@ -172,7 +175,7 @@
@Test
public void getImports_WrongType() {
- StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.IMPORTS, 123));
+ StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.IMPORTS, StarlarkInt.of(123)));
assertThrowsEvalExceptionContaining(
() -> PyStructUtils.getImports(info), "for imports, got int, want a depset of string");
}
@@ -190,7 +193,8 @@
@Test
public void getHasPy2OnlySources_WrongType() {
- StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY2_ONLY_SOURCES, 123));
+ StructImpl info =
+ makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY2_ONLY_SOURCES, StarlarkInt.of(123)));
assertHasWrongTypeMessage(
() -> PyStructUtils.getHasPy2OnlySources(info), "has_py2_only_sources", "bool");
}
@@ -208,7 +212,8 @@
@Test
public void getHasPy3OnlySources_WrongType() {
- StructImpl info = makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY3_ONLY_SOURCES, 123));
+ StructImpl info =
+ makeStruct(ImmutableMap.of(PyStructUtils.HAS_PY3_ONLY_SOURCES, StarlarkInt.of(123)));
assertHasWrongTypeMessage(
() -> PyStructUtils.getHasPy3OnlySources(info), "has_py3_only_sources", "bool");
}
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
index c505229..e274f4f 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/BzlLoadFunctionTest.java
@@ -47,6 +47,7 @@
import java.io.InputStream;
import java.util.UUID;
import javax.annotation.Nullable;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -402,7 +403,8 @@
SkyframeExecutorTestUtils.evaluate(
getSkyframeExecutor(), skyKey, /*keepGoing=*/ false, reporter);
- assertThat(result.get(skyKey).getModule().getGlobals()).containsEntry("a_symbol", 5);
+ assertThat(result.get(skyKey).getModule().getGlobals())
+ .containsEntry("a_symbol", StarlarkInt.of(5));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java b/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
index 3a1b30c..01c5faa 100644
--- a/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
+++ b/src/test/java/com/google/devtools/build/lib/skyframe/PackageFunctionTest.java
@@ -85,6 +85,7 @@
import java.util.concurrent.atomic.AtomicInteger;
import javax.annotation.Nullable;
import net.starlark.java.eval.Module;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -1254,7 +1255,7 @@
Module cViaB = bLoads.get(":c.bzl");
assertThat(cViaB).isSameInstanceAs(cViaA);
- assertThat(cViaA.getGlobal("c")).isEqualTo(0);
+ assertThat(cViaA.getGlobal("c")).isEqualTo(StarlarkInt.of(0));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
index fb74540..fb8086a 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkDefinedAspectsTest.java
@@ -52,6 +52,7 @@
import com.google.devtools.build.lib.skyframe.AspectValueKey.AspectKey;
import com.google.devtools.build.lib.vfs.FileSystemUtils;
import net.starlark.java.eval.Sequence;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -2460,7 +2461,7 @@
new StarlarkProvider.Key(
Label.parseAbsolute("//test:aspect.bzl", ImmutableMap.of()), "PCollector");
StructImpl collector = (StructImpl) configuredAspect.get(pCollector);
- assertThat(collector.getValue("attr_value")).isEqualTo(30);
+ assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30));
}
@Test
@@ -2515,7 +2516,7 @@
new StarlarkProvider.Key(
Label.parseAbsolute("//test:aspect.bzl", ImmutableMap.of()), "PCollector");
StructImpl collector = (StructImpl) configuredAspect.get(pCollector);
- assertThat(collector.getValue("attr_value")).isEqualTo(30);
+ assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
index 8d17f32..ac0aa23 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkIntegrationTest.java
@@ -59,6 +59,7 @@
import net.starlark.java.eval.NoneType;
import net.starlark.java.eval.Sequence;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkList;
import org.junit.Before;
import org.junit.Test;
@@ -1412,7 +1413,7 @@
StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
assertThat(declaredProvider).isNotNull();
assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
- assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+ assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -1437,7 +1438,7 @@
StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
assertThat(declaredProvider).isNotNull();
assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
- assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+ assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -1463,7 +1464,7 @@
StructImpl declaredProvider = (StructImpl) configuredTarget.get(key);
assertThat(declaredProvider).isNotNull();
assertThat(declaredProvider.getProvider().getKey()).isEqualTo(key);
- assertThat(declaredProvider.getValue("x")).isEqualTo(1);
+ assertThat(declaredProvider.getValue("x")).isEqualTo(StarlarkInt.of(1));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
index ea16805..ab72af3 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkOptionsParsingTest.java
@@ -23,6 +23,7 @@
import com.google.devtools.build.lib.util.Pair;
import com.google.devtools.common.options.OptionsParsingException;
import com.google.devtools.common.options.OptionsParsingResult;
+import net.starlark.java.eval.StarlarkInt;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -39,7 +40,8 @@
OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting=666");
assertThat(result.getStarlarkOptions()).hasSize(1);
- assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+ assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+ .isEqualTo(StarlarkInt.of(666));
assertThat(result.getResidue()).isEmpty();
}
@@ -51,7 +53,8 @@
OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting 666");
assertThat(result.getStarlarkOptions()).hasSize(1);
- assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(666);
+ assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+ .isEqualTo(StarlarkInt.of(666));
assertThat(result.getResidue()).isEmpty();
}
@@ -66,7 +69,7 @@
assertThat(result.getStarlarkOptions()).hasSize(1);
assertThat(result.getStarlarkOptions().get("@starlark_options_test//test:my_int_setting"))
- .isEqualTo(666);
+ .isEqualTo(StarlarkInt.of(666));
assertThat(result.getResidue()).isEmpty();
}
@@ -206,7 +209,8 @@
parseStarlarkOptions("--//test:my_int_setting=4 --//test:my_int_setting=7");
assertThat(result.getStarlarkOptions()).hasSize(1);
- assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(7);
+ assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+ .isEqualTo(StarlarkInt.of(7));
assertThat(result.getResidue()).isEmpty();
}
@@ -232,8 +236,10 @@
assertThat(result.getResidue()).isEmpty();
assertThat(result.getStarlarkOptions()).hasSize(2);
- assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(0);
- assertThat(result.getStarlarkOptions().get("//test:my_other_int_setting")).isEqualTo(0);
+ assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+ .isEqualTo(StarlarkInt.of(0));
+ assertThat(result.getStarlarkOptions().get("//test:my_other_int_setting"))
+ .isEqualTo(StarlarkInt.of(0));
}
// test --non_build_setting
@@ -318,7 +324,8 @@
OptionsParsingResult result = parseStarlarkOptions("--//test:my_int_setting=15");
- assertThat(result.getStarlarkOptions().get("//test:my_int_setting")).isEqualTo(15);
+ assertThat(result.getStarlarkOptions().get("//test:my_int_setting"))
+ .isEqualTo(StarlarkInt.of(15));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
index 7a87200..45c3d2b 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleClassFunctionsTest.java
@@ -61,6 +61,7 @@
import net.starlark.java.eval.Module;
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkList;
import net.starlark.java.eval.Tuple;
import net.starlark.java.syntax.ParserInput;
@@ -639,8 +640,8 @@
public void testAttrIntValues() throws Exception {
Attribute attr = buildAttribute("a1", "attr.int(values = [1, 2])");
PredicateWithMessage<Object> predicate = attr.getAllowedValues();
- assertThat(predicate.apply(2)).isTrue();
- assertThat(predicate.apply(3)).isFalse();
+ assertThat(predicate.apply(StarlarkInt.of(2))).isTrue();
+ assertThat(predicate.apply(StarlarkInt.of(3))).isFalse();
}
@Test
@@ -893,7 +894,50 @@
"r1 = rule(impl, attrs = {'a1': attr.int(default = 40+2)})");
RuleClass c = ((StarlarkRuleFunction) ev.lookup("r1")).getRuleClass();
Attribute a = c.getAttributeByName("a1");
- assertThat(a.getDefaultValueUnchecked()).isEqualTo(42);
+ assertThat(a.getDefaultValueUnchecked()).isEqualTo(StarlarkInt.of(42));
+ }
+
+ @Test
+ public void testIntDefaultValueMustBeInt32() throws Exception {
+ // This is a test of the loading phase. Move somewhere more appropriate.
+ ev.checkEvalErrorContains(
+ "for parameter 'default' of attribute '', got 4294967296, want value in signed 32-bit"
+ + " range",
+ "attr.int(default = 0x10000 * 0x10000)");
+ ev.checkEvalErrorContains(
+ "for element 0 of parameter 'default' of attribute '', got 4294967296, want value in"
+ + " signed 32-bit range",
+ "attr.int_list(default = [0x10000 * 0x10000])");
+ }
+
+ @Test
+ public void testIntAttributeValueMustBeInt32() throws Exception {
+ // This is a test of the loading phase. Move somewhere more appropriate.
+ scratch.file(
+ "p/inc.bzl", //
+ "def _impl(ctx): pass",
+ "r = rule(_impl, attrs = dict(i=attr.int()))");
+ scratch.file(
+ "p/BUILD", //
+ "load('inc.bzl', 'r')",
+ "r(name = 'p', i = 0x10000 * 0x10000)");
+ AssertionError expected = assertThrows(AssertionError.class, () -> createRuleContext("//p"));
+ assertThat(expected)
+ .hasMessageThat()
+ .contains(
+ "for attribute 'i' in 'r' rule, got 4294967296, want value in signed 32-bit range");
+ }
+
+ @Test
+ public void testIntegerConcatTruncates() throws Exception {
+ // The Type.INTEGER.concat operator, as used to resolve select(int)+select(int)
+ // after rule construction, has a range of int32.
+ scratch.file(
+ "p/BUILD", //
+ "s = select({'//conditions:default': -0x7fffffff})", // -0x7fffffff + -0x7fffffff = 2
+ "cc_test(name='c', shard_count = s+s)");
+ StarlarkRuleContext context = createRuleContext("//p:c");
+ assertThat(context.getAttr().getValue("shard_count")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1126,8 +1170,8 @@
// TODO(fwe): cannot be handled by current testing suite
ev.exec("x = struct(a = 1, b = 2)");
ClassObject x = (ClassObject) ev.lookup("x");
- assertThat(x.getValue("a")).isEqualTo(1);
- assertThat(x.getValue("b")).isEqualTo(2);
+ assertThat(x.getValue("a")).isEqualTo(StarlarkInt.of(1));
+ assertThat(x.getValue("b")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1162,8 +1206,8 @@
@Test
public void testStructAccessingFieldsFromStarlark() throws Exception {
ev.exec("x = struct(a = 1, b = 2)", "x1 = x.a", "x2 = x.b");
- assertThat(ev.lookup("x1")).isEqualTo(1);
- assertThat(ev.lookup("x2")).isEqualTo(2);
+ assertThat(ev.lookup("x1")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("x2")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1189,7 +1233,7 @@
@Test
public void testStructAccessingFunctionFieldWithArgs() throws Exception {
ev.exec("def f(x): return x+5", "x = struct(a = f, b = 2)", "x1 = x.a(1)");
- assertThat(ev.lookup("x1")).isEqualTo(6);
+ assertThat(ev.lookup("x1")).isEqualTo(StarlarkInt.of(6));
}
@Test
@@ -1217,10 +1261,10 @@
"y = struct(c = 1, d = 2)",
"z = x + y\n");
StructImpl z = (StructImpl) ev.lookup("z");
- assertThat(z.getValue("a")).isEqualTo(1);
- assertThat(z.getValue("b")).isEqualTo(2);
- assertThat(z.getValue("c")).isEqualTo(1);
- assertThat(z.getValue("d")).isEqualTo(2);
+ assertThat(z.getValue("a")).isEqualTo(StarlarkInt.of(1));
+ assertThat(z.getValue("b")).isEqualTo(StarlarkInt.of(2));
+ assertThat(z.getValue("c")).isEqualTo(StarlarkInt.of(1));
+ assertThat(z.getValue("d")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1243,10 +1287,10 @@
" return x",
"x = func()");
StructImpl x = (StructImpl) ev.lookup("x");
- assertThat(x.getValue("a")).isEqualTo(1);
- assertThat(x.getValue("b")).isEqualTo(2);
- assertThat(x.getValue("c")).isEqualTo(1);
- assertThat(x.getValue("d")).isEqualTo(2);
+ assertThat(x.getValue("a")).isEqualTo(StarlarkInt.of(1));
+ assertThat(x.getValue("b")).isEqualTo(StarlarkInt.of(2));
+ assertThat(x.getValue("c")).isEqualTo(StarlarkInt.of(1));
+ assertThat(x.getValue("d")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1301,7 +1345,7 @@
"s = struct(x = {'a' : 1})", //
"s.x['b'] = 2\n");
assertThat(((StructImpl) ev.lookup("s")).getValue("x"))
- .isEqualTo(ImmutableMap.of("a", 1, "b", 2));
+ .isEqualTo(ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
}
@Test
@@ -1324,21 +1368,22 @@
StarlarkList.<Object>of(
mu,
StructProvider.STRUCT.create(
- ImmutableMap.<String, Object>of("x", Dict.<Object, Object>of(mu, 1, 1)),
+ ImmutableMap.<String, Object>of(
+ "x", Dict.<Object, Object>of(mu, StarlarkInt.of(1), StarlarkInt.of(1))),
"no field '%s'"),
Tuple.of()),
"b", Tuple.of(),
- "c", Dict.<Object, Object>of(mu, 2, 2)),
+ "c", Dict.<Object, Object>of(mu, StarlarkInt.of(2), StarlarkInt.of(2))),
"no field '%s'");
}
@Test
public void testStructMutabilityShallow() throws Exception {
- assertThat(Starlark.isImmutable(makeStruct("a", 1))).isTrue();
+ assertThat(Starlark.isImmutable(makeStruct("a", StarlarkInt.of(1)))).isTrue();
}
private static StarlarkList<Object> makeList(@Nullable Mutability mu) {
- return StarlarkList.<Object>of(mu, 1, 2, 3);
+ return StarlarkList.<Object>of(mu, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3));
}
@Test
@@ -1356,7 +1401,7 @@
@Test
public void declaredProviders() throws Exception {
evalAndExport(ev, "data = provider()", "d = data(x = 1, y ='abc')", "d_x = d.x", "d_y = d.y");
- assertThat(ev.lookup("d_x")).isEqualTo(1);
+ assertThat(ev.lookup("d_x")).isEqualTo(StarlarkInt.of(1));
assertThat(ev.lookup("d_y")).isEqualTo("abc");
StarlarkProvider dataConstructor = (StarlarkProvider) ev.lookup("data");
StructImpl data = (StructImpl) ev.lookup("d");
@@ -1376,7 +1421,7 @@
"dxy = dx + dy",
"x = dxy.x",
"y = dxy.y");
- assertThat(ev.lookup("x")).isEqualTo(1);
+ assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
assertThat(ev.lookup("y")).isEqualTo("abc");
StarlarkProvider dataConstructor = (StarlarkProvider) ev.lookup("data");
StructImpl dx = (StructImpl) ev.lookup("dx");
@@ -1406,8 +1451,8 @@
"d3 = d1 + d2",
"f1 = d3.f1",
"f2 = d3.f2");
- assertThat(ev.lookup("f1")).isEqualTo(4);
- assertThat(ev.lookup("f2")).isEqualTo(5);
+ assertThat(ev.lookup("f1")).isEqualTo(StarlarkInt.of(4));
+ assertThat(ev.lookup("f2")).isEqualTo(StarlarkInt.of(5));
}
@Test
@@ -1632,8 +1677,8 @@
StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
assertThat(p1.getProvider()).isEqualTo(p);
- assertThat(ev.lookup("x")).isEqualTo(1);
- assertThat(ev.lookup("y")).isEqualTo(2);
+ assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1648,8 +1693,8 @@
StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
assertThat(p1.getProvider()).isEqualTo(p);
- assertThat(ev.lookup("x")).isEqualTo(1);
- assertThat(ev.lookup("y")).isEqualTo(2);
+ assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -1663,7 +1708,7 @@
StarlarkInfo p1 = (StarlarkInfo) ev.lookup("p1");
assertThat(p1.getProvider()).isEqualTo(p);
- assertThat(ev.lookup("y")).isEqualTo(2);
+ assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(2));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
index 52465e3..de47e1d 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleContextTest.java
@@ -64,6 +64,7 @@
import net.starlark.java.eval.Mutability;
import net.starlark.java.eval.Sequence;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkList;
import org.junit.Before;
import org.junit.Test;
@@ -2614,7 +2615,7 @@
"BuildSettingInfo");
StructImpl buildSettingInfo = (StructImpl) buildSetting.get(key);
- assertThat(buildSettingInfo.getValue("value")).isEqualTo(24);
+ assertThat(buildSettingInfo.getValue("value")).isEqualTo(StarlarkInt.of(24));
}
@Test
@@ -2628,7 +2629,7 @@
"BuildSettingInfo");
StructImpl buildSettingInfo = (StructImpl) buildSetting.get(key);
- assertThat(buildSettingInfo.getValue("value")).isEqualTo(42);
+ assertThat(buildSettingInfo.getValue("value")).isEqualTo(StarlarkInt.of(42));
}
@Test
diff --git a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
index aec46ba..f41a7c2 100644
--- a/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
+++ b/src/test/java/com/google/devtools/build/lib/starlark/StarlarkRuleImplementationFunctionsTest.java
@@ -74,6 +74,7 @@
import net.starlark.java.eval.Printer;
import net.starlark.java.eval.Sequence;
import net.starlark.java.eval.Starlark;
+import net.starlark.java.eval.StarlarkInt;
import net.starlark.java.eval.StarlarkList;
import net.starlark.java.eval.StarlarkThread;
import org.junit.Before;
@@ -1511,7 +1512,7 @@
.isEqualTo(
new StarlarkProvider.Key(
Label.parseAbsolute("//test:foo.bzl", ImmutableMap.of()), "foo_provider"));
- assertThat(((StructImpl) provider).getValue("a")).isEqualTo(123);
+ assertThat(((StructImpl) provider).getValue("a")).isEqualTo(StarlarkInt.of(123));
}
@Test
@@ -2311,15 +2312,15 @@
public void testArgsAddInvalidTypesForArgAndValues() throws Exception {
setRuleContext(createRuleContext("//foo:foo"));
ev.checkEvalErrorContains(
- "expected value of type 'string' for arg name, got 'Integer'",
+ "expected value of type 'string' for arg name, got 'int'",
"args = ruleContext.actions.args()",
"args.add(1, 'value')");
ev.checkEvalErrorContains(
- "expected value of type 'string' for arg name, got 'Integer'",
+ "expected value of type 'string' for arg name, got 'int'",
"args = ruleContext.actions.args()",
"args.add_all(1, [1, 2])");
ev.checkEvalErrorContains(
- "expected value of type 'sequence or depset' for values, got 'Integer'",
+ "expected value of type 'sequence or depset' for values, got 'int'",
"args = ruleContext.actions.args()",
"args.add_all(1)");
ev.checkEvalErrorContains(
@@ -2417,7 +2418,7 @@
CommandLineExpansionException e =
assertThrows(CommandLineExpansionException.class, () -> action.getArguments());
assertThat(e.getMessage())
- .contains("Expected map_each to return string, None, or list of strings, found Integer");
+ .contains("Expected map_each to return string, None, or list of strings, found int");
}
@Test
diff --git a/src/test/java/net/starlark/java/eval/BUILD b/src/test/java/net/starlark/java/eval/BUILD
index a0de839..896039d 100644
--- a/src/test/java/net/starlark/java/eval/BUILD
+++ b/src/test/java/net/starlark/java/eval/BUILD
@@ -56,7 +56,6 @@
"testdata/function.sky",
"testdata/int.sky",
"testdata/int_constructor.sky",
- "testdata/int_function.sky",
"testdata/list_mutation.sky",
"testdata/list_slices.sky",
"testdata/min_max.sky",
diff --git a/src/test/java/net/starlark/java/eval/EvalUtilsTest.java b/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
index 0054d63..71bd1f7 100644
--- a/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
+++ b/src/test/java/net/starlark/java/eval/EvalUtilsTest.java
@@ -17,6 +17,7 @@
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
+import java.math.BigInteger;
import javax.annotation.Nullable;
import net.starlark.java.annot.StarlarkBuiltin;
import org.junit.Test;
@@ -61,12 +62,14 @@
@Test
public void testDatatypeMutabilityPrimitive() throws Exception {
assertThat(Starlark.isImmutable("foo")).isTrue();
- assertThat(Starlark.isImmutable(3)).isTrue();
+ assertThat(Starlark.isImmutable(StarlarkInt.of(3))).isTrue();
}
@Test
public void testDatatypeMutabilityShallow() throws Exception {
- assertThat(Starlark.isImmutable(Tuple.of(1, 2, 3))).isTrue();
+ assertThat(
+ Starlark.isImmutable(Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+ .isTrue();
assertThat(Starlark.isImmutable(makeList(null))).isTrue();
assertThat(Starlark.isImmutable(makeDict(null))).isTrue();
@@ -91,15 +94,15 @@
Object[] objects = {
"1",
- 2,
+ StarlarkInt.of(2),
true,
Starlark.NONE,
- Tuple.of(1, 2, 3),
+ Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)),
Tuple.of("1", "2", "3"),
- StarlarkList.of(mu, 1, 2, 3),
+ StarlarkList.of(mu, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)),
StarlarkList.of(mu, "1", "2", "3"),
- Dict.of(mu, "key", 123),
- Dict.of(mu, 123, "value"),
+ Dict.of(mu, "key", StarlarkInt.of(123)),
+ Dict.of(mu, StarlarkInt.of(123), "value"),
myValue,
};
@@ -126,10 +129,47 @@
@Test
public void testLen() {
assertThat(Starlark.len("abc")).isEqualTo(3);
- assertThat(Starlark.len(Tuple.of(1, 2, 3))).isEqualTo(3);
- assertThat(Starlark.len(StarlarkList.of(null, 1, 2, 3))).isEqualTo(3);
- assertThat(Starlark.len(Dict.of(null, "one", 1, "two", 2))).isEqualTo(2);
+ assertThat(Starlark.len(Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+ .isEqualTo(3);
+ assertThat(
+ Starlark.len(
+ StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+ .isEqualTo(3);
+ assertThat(Starlark.len(Dict.of(null, "one", StarlarkInt.of(1), "two", StarlarkInt.of(2))))
+ .isEqualTo(2);
assertThat(Starlark.len(true)).isEqualTo(-1);
assertThrows(IllegalArgumentException.class, () -> Starlark.len(this));
}
+
+ @Test
+ public void testIntConstructor() throws Exception {
+ // small values are cached
+ assertThat(StarlarkInt.of(-1)).isSameInstanceAs(StarlarkInt.of(-1));
+ assertThat(StarlarkInt.of(0)).isSameInstanceAs(StarlarkInt.ZERO);
+ assertThat(StarlarkInt.of(123)).isSameInstanceAs(StarlarkInt.of(123));
+ // int32
+ assertThat(StarlarkInt.of(0).getClass().getSimpleName()).isEqualTo("Int32");
+ assertThat(StarlarkInt.of(Integer.MAX_VALUE).getClass().getSimpleName()).isEqualTo("Int32");
+ assertThat(StarlarkInt.of(Integer.MIN_VALUE).getClass().getSimpleName()).isEqualTo("Int32");
+ // int64
+ assertThat(StarlarkInt.of((long) Integer.MAX_VALUE + 1).getClass().getSimpleName())
+ .isEqualTo("Int64");
+ assertThat(StarlarkInt.of((long) Integer.MIN_VALUE - 1).getClass().getSimpleName())
+ .isEqualTo("Int64");
+ assertThat(StarlarkInt.of(Long.MAX_VALUE).getClass().getSimpleName()).isEqualTo("Int64");
+ assertThat(StarlarkInt.of(Long.MIN_VALUE).getClass().getSimpleName()).isEqualTo("Int64");
+ // big
+ assertThat(StarlarkInt.of(new BigInteger("7fffffffffffffff", 16)).getClass().getSimpleName())
+ .isEqualTo("Int64"); // (max long)
+ assertThat(StarlarkInt.of(new BigInteger("8000000000000000", 16)).getClass().getSimpleName())
+ .isEqualTo("Big");
+ assertThat(StarlarkInt.of(new BigInteger("8000000000000001", 16)).getClass().getSimpleName())
+ .isEqualTo("Big");
+ assertThat(StarlarkInt.of(new BigInteger("-7fffffffffffffff", 16)).getClass().getSimpleName())
+ .isEqualTo("Int64");
+ assertThat(StarlarkInt.of(new BigInteger("-8000000000000000", 16)).getClass().getSimpleName())
+ .isEqualTo("Int64"); // (min long)
+ assertThat(StarlarkInt.of(new BigInteger("-8000000000000001", 16)).getClass().getSimpleName())
+ .isEqualTo("Big");
+ }
}
diff --git a/src/test/java/net/starlark/java/eval/EvaluationTest.java b/src/test/java/net/starlark/java/eval/EvaluationTest.java
index 3020e60..f1c47f8 100644
--- a/src/test/java/net/starlark/java/eval/EvaluationTest.java
+++ b/src/test/java/net/starlark/java/eval/EvaluationTest.java
@@ -170,17 +170,19 @@
.testExpression("'%sx' % 'foo' + 'bar1'", "fooxbar1")
.testExpression("('%sx' % 'foo') + 'bar2'", "fooxbar2")
.testExpression("'%sx' % ('foo' + 'bar3')", "foobar3x")
- .testExpression("123 + 456", 579)
- .testExpression("456 - 123", 333)
- .testExpression("8 % 3", 2)
+ .testExpression("123 + 456", StarlarkInt.of(579))
+ .testExpression("456 - 123", StarlarkInt.of(333))
+ .testExpression("8 % 3", StarlarkInt.of(2))
.testIfErrorContains("unsupported binary operation: int % string", "3 % 'foo'")
- .testExpression("-5", -5)
+ .testExpression("-5", StarlarkInt.of(-5))
.testIfErrorContains("unsupported unary operation: -string", "-'foo'");
}
@Test
public void testListExprs() throws Exception {
- ev.new Scenario().testExactOrder("[1, 2, 3]", 1, 2, 3).testExactOrder("(1, 2, 3)", 1, 2, 3);
+ ev.new Scenario()
+ .testExactOrder("[1, 2, 3]", StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))
+ .testExactOrder("(1, 2, 3)", StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3));
}
@Test
@@ -191,9 +193,9 @@
@Test
public void testConditionalExpressions() throws Exception {
ev.new Scenario()
- .testExpression("1 if True else 2", 1)
- .testExpression("1 if False else 2", 2)
- .testExpression("1 + 2 if 3 + 4 else 5 + 6", 3);
+ .testExpression("1 if True else 2", StarlarkInt.of(1))
+ .testExpression("1 if False else 2", StarlarkInt.of(2))
+ .testExpression("1 + 2 if 3 + 4 else 5 + 6", StarlarkInt.of(3));
}
@Test
@@ -226,10 +228,11 @@
}
@Override
- public Object fastcall(StarlarkThread thread, Object[] positional, Object[] named) {
- int sum = 0;
+ public StarlarkInt fastcall(StarlarkThread thread, Object[] positional, Object[] named)
+ throws EvalException {
+ StarlarkInt sum = StarlarkInt.of(0);
for (Object arg : positional) {
- sum += (Integer) arg;
+ sum = StarlarkInt.add(sum, (StarlarkInt) arg);
}
return sum;
}
@@ -237,18 +240,18 @@
ev.new Scenario()
.update(sum.getName(), sum)
- .testExpression("sum(1, 2, 3, 4, 5, 6)", 21)
+ .testExpression("sum(1, 2, 3, 4, 5, 6)", StarlarkInt.of(21))
.testExpression("sum", sum)
- .testExpression("sum(a=1, b=2)", 0);
+ .testExpression("sum(a=1, b=2)", StarlarkInt.of(0));
}
@Test
public void testNotCallInt() throws Exception {
ev.new Scenario()
.setUp("sum = 123456")
- .testLookup("sum", 123456)
+ .testLookup("sum", StarlarkInt.of(123456))
.testIfExactError("'int' object is not callable", "sum(1, 2, 3, 4, 5, 6)")
- .testExpression("sum", 123456);
+ .testExpression("sum", StarlarkInt.of(123456));
}
@Test
@@ -290,19 +293,19 @@
@Test
public void testModulo() throws Exception {
ev.new Scenario()
- .testExpression("6 % 2", 0)
- .testExpression("6 % 4", 2)
- .testExpression("3 % 6", 3)
- .testExpression("7 % -4", -1)
- .testExpression("-7 % 4", 1)
- .testExpression("-7 % -4", -3)
+ .testExpression("6 % 2", StarlarkInt.of(0))
+ .testExpression("6 % 4", StarlarkInt.of(2))
+ .testExpression("3 % 6", StarlarkInt.of(3))
+ .testExpression("7 % -4", StarlarkInt.of(-1))
+ .testExpression("-7 % 4", StarlarkInt.of(1))
+ .testExpression("-7 % -4", StarlarkInt.of(-3))
.testIfExactError("integer modulo by zero", "5 % 0");
}
@Test
public void testMult() throws Exception {
ev.new Scenario()
- .testExpression("6 * 7", 42)
+ .testExpression("6 * 7", StarlarkInt.of(42))
.testExpression("3 * 'ab'", "ababab")
.testExpression("0 * 'ab'", "")
.testExpression("'1' + '0' * 5", "100000")
@@ -318,35 +321,38 @@
@Test
public void testFloorDivision() throws Exception {
ev.new Scenario()
- .testExpression("6 // 2", 3)
- .testExpression("6 // 4", 1)
- .testExpression("3 // 6", 0)
- .testExpression("7 // -2", -4)
- .testExpression("-7 // 2", -4)
- .testExpression("-7 // -2", 3)
- .testExpression("2147483647 // 2", 1073741823)
+ .testExpression("6 // 2", StarlarkInt.of(3))
+ .testExpression("6 // 4", StarlarkInt.of(1))
+ .testExpression("3 // 6", StarlarkInt.of(0))
+ .testExpression("7 // -2", StarlarkInt.of(-4))
+ .testExpression("-7 // 2", StarlarkInt.of(-4))
+ .testExpression("-7 // -2", StarlarkInt.of(3))
+ .testExpression("2147483647 // 2", StarlarkInt.of(1073741823))
.testIfErrorContains("unsupported binary operation: string // int", "'str' // 2")
.testIfExactError("integer division by zero", "5 // 0");
}
@Test
- public void testCheckedArithmetic() throws Exception {
+ public void testArithmeticDoesNotOverflow() throws Exception {
ev.new Scenario()
- .testIfErrorContains("integer overflow", "2000000000 + 2000000000")
- .testIfErrorContains("integer overflow", "1234567890 * 987654321")
- .testIfErrorContains("integer overflow", "- 2000000000 - 2000000000")
+ .testEval("2000000000 + 2000000000", "1000000000 + 1000000000 + 1000000000 + 1000000000")
+ .testExpression("1234567890 * 987654321", StarlarkInt.of(1219326311126352690L))
+ .testExpression(
+ "1234567890 * 987654321 * 987654321",
+ StarlarkInt.multiply(StarlarkInt.of(1219326311126352690L), StarlarkInt.of(987654321)))
+ .testEval("- 2000000000 - 2000000000", "-1000000000 - 1000000000 - 1000000000 - 1000000000")
// literal 2147483648 is not allowed, so we compute it
.setUp("minint = - 2147483647 - 1")
- .testIfErrorContains("integer overflow", "-minint");
+ .testEval("-minint", "2147483647+1");
}
@Test
public void testOperatorPrecedence() throws Exception {
ev.new Scenario()
- .testExpression("2 + 3 * 4", 14)
- .testExpression("2 + 3 // 4", 2)
- .testExpression("2 * 3 + 4 // -2", 4);
+ .testExpression("2 + 3 * 4", StarlarkInt.of(14))
+ .testExpression("2 + 3 // 4", StarlarkInt.of(2))
+ .testExpression("2 * 3 + 4 // -2", StarlarkInt.of(4));
}
@Test
@@ -357,22 +363,38 @@
@Test
public void testConcatLists() throws Exception {
ev.new Scenario()
- .testExactOrder("[1,2] + [3,4]", 1, 2, 3, 4)
- .testExactOrder("(1,2)", 1, 2)
- .testExactOrder("(1,2) + (3,4)", 1, 2, 3, 4);
+ .testExactOrder(
+ "[1,2] + [3,4]",
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ StarlarkInt.of(3),
+ StarlarkInt.of(4))
+ .testExactOrder("(1,2)", StarlarkInt.of(1), StarlarkInt.of(2))
+ .testExactOrder(
+ "(1,2) + (3,4)",
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ StarlarkInt.of(3),
+ StarlarkInt.of(4));
// TODO(fwe): cannot be handled by current testing suite
// list
Object x = ev.eval("[1,2] + [3,4]");
- assertThat((Iterable<?>) x).containsExactly(1, 2, 3, 4).inOrder();
+ assertThat((Iterable<?>) x)
+ .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))
+ .inOrder();
assertThat(x).isInstanceOf(StarlarkList.class);
assertThat(Starlark.isImmutable(x)).isFalse();
// tuple
x = ev.eval("(1,2) + (3,4)");
- assertThat((Iterable<?>) x).containsExactly(1, 2, 3, 4).inOrder();
+ assertThat((Iterable<?>) x)
+ .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))
+ .inOrder();
assertThat(x).isInstanceOf(Tuple.class);
- assertThat(x).isEqualTo(Tuple.of(1, 2, 3, 4));
+ assertThat(x)
+ .isEqualTo(
+ Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4)));
assertThat(Starlark.isImmutable(x)).isTrue();
ev.checkEvalError("unsupported binary operation: tuple + list", "(1,2) + [3,4]");
@@ -416,15 +438,20 @@
"bar/wiz.cc",
"bar/quux.java",
"bar/quux.cc")
- .testExactOrder("[i for i in (1, 2)]", 1, 2)
- .testExactOrder("[i for i in [2, 3] or [1, 2]]", 2, 3);
+ .testExactOrder("[i for i in (1, 2)]", StarlarkInt.of(1), StarlarkInt.of(2))
+ .testExactOrder("[i for i in [2, 3] or [1, 2]]", StarlarkInt.of(2), StarlarkInt.of(3));
}
@Test
public void testNestedListComprehensions() throws Exception {
ev.new Scenario()
.setUp("li = [[1, 2], [3, 4]]")
- .testExactOrder("[j for i in li for j in i]", 1, 2, 3, 4);
+ .testExactOrder(
+ "[j for i in li for j in i]",
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ StarlarkInt.of(3),
+ StarlarkInt.of(4));
ev.new Scenario()
.setUp("input = [['abc'], ['def', 'ghi']]\n")
.testExactOrder(
@@ -566,8 +593,8 @@
public void testTupleDestructuring() throws Exception {
ev.new Scenario()
.setUp("a, b = 1, 2")
- .testLookup("a", 1)
- .testLookup("b", 2)
+ .testLookup("a", StarlarkInt.of(1))
+ .testLookup("b", StarlarkInt.of(2))
.setUp("c, d = {'key1':2, 'key2':3}")
.testLookup("c", "key1")
.testLookup("d", "key2");
@@ -575,20 +602,20 @@
@Test
public void testSingleTuple() throws Exception {
- ev.new Scenario().setUp("(a,) = [1]").testLookup("a", 1);
+ ev.new Scenario().setUp("(a,) = [1]").testLookup("a", StarlarkInt.of(1));
}
@Test
public void testHeterogeneousDict() throws Exception {
ev.new Scenario()
.setUp("d = {'str': 1, 2: 3}", "a = d['str']", "b = d[2]")
- .testLookup("a", 1)
- .testLookup("b", 3);
+ .testLookup("a", StarlarkInt.of(1))
+ .testLookup("b", StarlarkInt.of(3));
}
@Test
public void testAccessDictWithATupleKey() throws Exception {
- ev.new Scenario().setUp("x = {(1, 2): 3}[1, 2]").testLookup("x", 3);
+ ev.new Scenario().setUp("x = {(1, 2): 3}[1, 2]").testLookup("x", StarlarkInt.of(3));
}
@Test
@@ -602,26 +629,29 @@
public void testRecursiveTupleDestructuring() throws Exception {
ev.new Scenario()
.setUp("((a, b), (c, d)) = [(1, 2), (3, 4)]")
- .testLookup("a", 1)
- .testLookup("b", 2)
- .testLookup("c", 3)
- .testLookup("d", 4);
+ .testLookup("a", StarlarkInt.of(1))
+ .testLookup("b", StarlarkInt.of(2))
+ .testLookup("c", StarlarkInt.of(3))
+ .testLookup("d", StarlarkInt.of(4));
}
@Test
public void testListComprehensionAtTopLevel() throws Exception {
// It is allowed to have a loop variable with the same name as a global variable.
ev.new Scenario()
- .update("x", 42)
+ .update("x", StarlarkInt.of(42))
.setUp("y = [x + 1 for x in [1,2,3]]")
- .testExactOrder("y", 2, 3, 4);
+ .testExactOrder("y", StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4));
}
@Test
public void testDictComprehensions() throws Exception {
ev.new Scenario()
.testExpression("{a : a for a in []}", Collections.emptyMap())
- .testExpression("{b : b for b in [1, 2]}", ImmutableMap.of(1, 1, 2, 2))
+ .testExpression(
+ "{b : b for b in [1, 2]}",
+ ImmutableMap.of(
+ StarlarkInt.of(1), StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(2)))
.testExpression(
"{c : 'v_' + c for c in ['a', 'b']}", ImmutableMap.of("a", "v_a", "b", "v_b"))
.testExpression(
@@ -629,7 +659,9 @@
.testExpression(
"{'k_' + e : 'v_' + e for e in ['a', 'b']}",
ImmutableMap.of("k_a", "v_a", "k_b", "v_b"))
- .testExpression("{x+y : x*y for x, y in [[2, 3]]}", ImmutableMap.of(5, 6));
+ .testExpression(
+ "{x+y : x*y for x, y in [[2, 3]]}",
+ ImmutableMap.of(StarlarkInt.of(5), StarlarkInt.of(6)));
}
@Test
@@ -642,13 +674,24 @@
ev.new Scenario()
.testExpression(
"{x : x * y for x in range(1, 10) if x % 2 == 0 for y in range(1, 10) if y == x}",
- ImmutableMap.of(2, 4, 4, 16, 6, 36, 8, 64));
+ ImmutableMap.of(
+ StarlarkInt.of(2),
+ StarlarkInt.of(4),
+ StarlarkInt.of(4),
+ StarlarkInt.of(16),
+ StarlarkInt.of(6),
+ StarlarkInt.of(36),
+ StarlarkInt.of(8),
+ StarlarkInt.of(64)));
}
@Test
public void testDictComprehensions_multipleKey() throws Exception {
ev.new Scenario()
- .testExpression("{x : x for x in [1, 2, 1]}", ImmutableMap.of(1, 1, 2, 2))
+ .testExpression(
+ "{x : x for x in [1, 2, 1]}",
+ ImmutableMap.of(
+ StarlarkInt.of(1), StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(2)))
.testExpression(
"{y : y for y in ['ab', 'c', 'a' + 'b']}", ImmutableMap.of("ab", "ab", "c", "c"));
}
@@ -656,45 +699,44 @@
@Test
public void testListConcatenation() throws Exception {
ev.new Scenario()
- .testExpression("[1, 2] + [3, 4]", StarlarkList.of(null, 1, 2, 3, 4))
- .testExpression("(1, 2) + (3, 4)", Tuple.of(1, 2, 3, 4))
+ .testEval("[1, 2] + [3, 4]", "[1, 2, 3, 4]")
+ .testEval("(1, 2) + (3, 4)", "(1, 2, 3, 4)")
.testIfExactError("unsupported binary operation: list + tuple", "[1, 2] + (3, 4)")
.testIfExactError("unsupported binary operation: tuple + list", "(1, 2) + [3, 4]");
}
@Test
public void testListMultiply() throws Exception {
- Mutability mu = Mutability.create("test");
ev.new Scenario()
- .testExpression("[1, 2, 3] * 1", StarlarkList.of(mu, 1, 2, 3))
- .testExpression("[1, 2] * 2", StarlarkList.of(mu, 1, 2, 1, 2))
- .testExpression("[1, 2] * 3", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2))
- .testExpression("[1, 2] * 4", StarlarkList.of(mu, 1, 2, 1, 2, 1, 2, 1, 2))
- .testExpression("[8] * 5", StarlarkList.of(mu, 8, 8, 8, 8, 8))
- .testExpression("[ ] * 10", StarlarkList.empty())
- .testExpression("[1, 2] * 0", StarlarkList.empty())
- .testExpression("[1, 2] * -4", StarlarkList.empty())
- .testExpression("2 * [1, 2]", StarlarkList.of(mu, 1, 2, 1, 2))
- .testExpression("10 * []", StarlarkList.empty())
- .testExpression("0 * [1, 2]", StarlarkList.empty())
- .testExpression("-4 * [1, 2]", StarlarkList.empty());
+ .testEval("[1, 2, 3] * 1", "[1, 2, 3]")
+ .testEval("[1, 2] * 2", "[1, 2, 1, 2]")
+ .testEval("[1, 2] * 3", "[1, 2, 1, 2, 1, 2]")
+ .testEval("[1, 2] * 4", "[1, 2, 1, 2, 1, 2, 1, 2]")
+ .testEval("[8] * 5", "[8, 8, 8, 8, 8]")
+ .testEval("[ ] * 10", "[]")
+ .testEval("[1, 2] * 0", "[]")
+ .testEval("[1, 2] * -4", "[]")
+ .testEval("2 * [1, 2]", "[1, 2, 1, 2]")
+ .testEval("10 * []", "[]")
+ .testEval("0 * [1, 2]", "[]")
+ .testEval("-4 * [1, 2]", "[]");
}
@Test
public void testTupleMultiply() throws Exception {
ev.new Scenario()
- .testExpression("(1, 2, 3) * 1", Tuple.of(1, 2, 3))
- .testExpression("(1, 2) * 2", Tuple.of(1, 2, 1, 2))
- .testExpression("(1, 2) * 3", Tuple.of(1, 2, 1, 2, 1, 2))
- .testExpression("(1, 2) * 4", Tuple.of(1, 2, 1, 2, 1, 2, 1, 2))
- .testExpression("(8,) * 5", Tuple.of(8, 8, 8, 8, 8))
- .testExpression("( ) * 10", Tuple.empty())
- .testExpression("(1, 2) * 0", Tuple.empty())
- .testExpression("(1, 2) * -4", Tuple.empty())
- .testExpression("2 * (1, 2)", Tuple.of(1, 2, 1, 2))
- .testExpression("10 * ()", Tuple.empty())
- .testExpression("0 * (1, 2)", Tuple.empty())
- .testExpression("-4 * (1, 2)", Tuple.empty());
+ .testEval("(1, 2, 3) * 1", "(1, 2, 3)")
+ .testEval("(1, 2) * 2", "(1, 2, 1, 2)")
+ .testEval("(1, 2) * 3", "(1, 2, 1, 2, 1, 2)")
+ .testEval("(1, 2) * 4", "(1, 2, 1, 2, 1, 2, 1, 2)")
+ .testEval("(8,) * 5", "(8, 8, 8, 8, 8)")
+ .testEval("( ) * 10", "()")
+ .testEval("(1, 2) * 0", "()")
+ .testEval("(1, 2) * -4", "()")
+ .testEval("2 * (1, 2)", "(1, 2, 1, 2)")
+ .testEval("10 * ()", "()")
+ .testEval("0 * (1, 2)", "()")
+ .testEval("-4 * (1, 2)", "()");
}
@Test
@@ -809,7 +851,7 @@
@Test
public void testInCompositeForPrecedence() throws Exception {
- ev.new Scenario().testExpression("not 'a' in ['a'] or 0", 0);
+ ev.new Scenario().testExpression("not 'a' in ['a'] or 0", StarlarkInt.of(0));
}
private static StarlarkValue createObjWithStr() {
@@ -913,6 +955,15 @@
Starlark.execFile(input, FileOptions.DEFAULT, module, thread);
}
assertThat(module.getGlobal("x"))
- .isEqualTo(StarlarkList.of(/*mutability=*/ null, 1, 2, "foo", 4, 1, 2, "foo1"));
+ .isEqualTo(
+ StarlarkList.of(
+ /*mutability=*/ null,
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ "foo",
+ StarlarkInt.of(4),
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ "foo1"));
}
}
diff --git a/src/test/java/net/starlark/java/eval/FunctionTest.java b/src/test/java/net/starlark/java/eval/FunctionTest.java
index 6aeb4c7..519cb52 100644
--- a/src/test/java/net/starlark/java/eval/FunctionTest.java
+++ b/src/test/java/net/starlark/java/eval/FunctionTest.java
@@ -38,7 +38,9 @@
.inOrder();
assertThat(f.hasVarargs()).isTrue();
assertThat(f.hasKwargs()).isTrue();
- assertThat(getDefaults(f)).containsExactly(null, 1, null, 2, null, null).inOrder();
+ assertThat(getDefaults(f))
+ .containsExactly(null, StarlarkInt.of(1), null, StarlarkInt.of(2), null, null)
+ .inOrder();
// same, sans varargs
ev.exec("def g(a, b=1, *, c, d=2, **kwargs): pass");
@@ -46,7 +48,9 @@
assertThat(g.getParameterNames()).containsExactly("a", "b", "c", "d", "kwargs").inOrder();
assertThat(g.hasVarargs()).isFalse();
assertThat(g.hasKwargs()).isTrue();
- assertThat(getDefaults(g)).containsExactly(null, 1, null, 2, null).inOrder();
+ assertThat(getDefaults(g))
+ .containsExactly(null, StarlarkInt.of(1), null, StarlarkInt.of(2), null)
+ .inOrder();
}
private static List<Object> getDefaults(StarlarkFunction fn) {
@@ -66,7 +70,7 @@
" outer_func(a)",
"func(1)",
"func(2)");
- assertThat(params).containsExactly(1, 2).inOrder();
+ assertThat(params).containsExactly(StarlarkInt.of(1), StarlarkInt.of(2)).inOrder();
}
private void createOuterFunction(final List<Object> params) throws Exception {
@@ -90,12 +94,12 @@
@Test
public void testFunctionDefNoEffectOutsideScope() throws Exception {
- ev.update("a", 1);
+ ev.update("a", StarlarkInt.of(1));
ev.exec(
"def func():", //
" a = 2",
"func()\n");
- assertThat(ev.lookup("a")).isEqualTo(1);
+ assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -106,7 +110,7 @@
" b = a",
" return b",
"c = func()\n");
- assertThat(ev.lookup("c")).isEqualTo(1);
+ assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -118,7 +122,7 @@
" b = a",
" return b",
"c = func()\n");
- assertThat(ev.lookup("c")).isEqualTo(2);
+ assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -156,14 +160,16 @@
" a = 3",
" return b",
"c = func()\n");
- assertThat(ev.lookup("c")).isEqualTo(2);
+ assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(2));
}
@SuppressWarnings("unchecked")
@Test
public void testStarlarkGlobalComprehensionIsAllowed() throws Exception {
ev.exec("a = [i for i in [1, 2, 3]]\n");
- assertThat((Iterable<Object>) ev.lookup("a")).containsExactly(1, 2, 3).inOrder();
+ assertThat((Iterable<Object>) ev.lookup("a"))
+ .containsExactly(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))
+ .inOrder();
}
@Test
@@ -172,7 +178,7 @@
"def func():", //
" return 2",
"b = func()\n");
- assertThat(ev.lookup("b")).isEqualTo(2);
+ assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -182,7 +188,7 @@
" for i in [1, 2, 3, 4, 5]:",
" return i",
"b = func()\n");
- assertThat(ev.lookup("b")).isEqualTo(1);
+ assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -195,8 +201,8 @@
" return b",
"c = func(0)",
"d = func(1)\n");
- assertThat(ev.lookup("c")).isEqualTo(1);
- assertThat(ev.lookup("d")).isEqualTo(2);
+ assertThat(ev.lookup("c")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("d")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -210,7 +216,7 @@
" func2(b)",
"func1(1)",
"func1(2)\n");
- assertThat(params).containsExactly(1, 2).inOrder();
+ assertThat(params).containsExactly(StarlarkInt.of(1), StarlarkInt.of(2)).inOrder();
}
@Test
@@ -222,7 +228,7 @@
"def func1():",
" return func2()",
"b = func1()\n");
- assertThat(ev.lookup("b")).isEqualTo(1);
+ assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -235,7 +241,7 @@
" dummy = a",
" return func2(2)",
"b = func1()\n");
- assertThat(ev.lookup("b")).isEqualTo(0);
+ assertThat(ev.lookup("b")).isEqualTo(StarlarkInt.of(0));
}
@Test
@@ -252,7 +258,7 @@
"def func(): return {'a' : 1}", //
"d = func()",
"a = d['a']\n");
- assertThat(ev.lookup("a")).isEqualTo(1);
+ assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -261,7 +267,7 @@
"def func(): return [1, 2, 3]", //
"d = func()",
"a = d[1]\n");
- assertThat(ev.lookup("a")).isEqualTo(2);
+ assertThat(ev.lookup("a")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -271,7 +277,7 @@
" return a + 1",
"alias = func",
"r = alias(1)");
- assertThat(ev.lookup("r")).isEqualTo(2);
+ assertThat(ev.lookup("r")).isEqualTo(StarlarkInt.of(2));
}
@Test
@@ -280,7 +286,7 @@
"def func(a, b, c):", //
" return a + b + c",
"v = func(1, c = 2, b = 3)");
- assertThat(ev.lookup("v")).isEqualTo(6);
+ assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(6));
}
private String functionWithOptionalArgs() {
@@ -448,7 +454,7 @@
" a = 3",
" return foo()",
"v = bar()\n");
- assertThat(ev.lookup("v")).isEqualTo(2);
+ assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(2));
}
@Test
diff --git a/src/test/java/net/starlark/java/eval/MethodLibraryTest.java b/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
index ede15a6..775be58 100644
--- a/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
+++ b/src/test/java/net/starlark/java/eval/MethodLibraryTest.java
@@ -312,13 +312,13 @@
public void testDictionaryAccess() throws Exception {
ev.new Scenario()
.testEval("{1: ['foo']}[1]", "['foo']")
- .testExpression("{'4': 8}['4']", 8)
+ .testExpression("{'4': 8}['4']", StarlarkInt.of(8))
.testExpression("{'a': 'aa', 'b': 'bb', 'c': 'cc'}['b']", "bb");
}
@Test
public void testDictionaryVariableAccess() throws Exception {
- ev.new Scenario().setUp("d = {'a' : 1}", "a = d['a']").testLookup("a", 1);
+ ev.new Scenario().setUp("d = {'a' : 1}", "a = d['a']").testLookup("a", StarlarkInt.of(1));
}
@Test
@@ -482,12 +482,12 @@
@Test
public void testListIndexMethod() throws Exception {
ev.new Scenario()
- .testExpression("['a', 'b', 'c'].index('a')", 0)
- .testExpression("['a', 'b', 'c'].index('b')", 1)
- .testExpression("['a', 'b', 'c'].index('c')", 2)
- .testExpression("[2, 4, 6].index(4)", 1)
- .testExpression("[2, 4, 6].index(4)", 1)
- .testExpression("[0, 1, [1]].index([1])", 2)
+ .testExpression("['a', 'b', 'c'].index('a')", StarlarkInt.of(0))
+ .testExpression("['a', 'b', 'c'].index('b')", StarlarkInt.of(1))
+ .testExpression("['a', 'b', 'c'].index('c')", StarlarkInt.of(2))
+ .testExpression("[2, 4, 6].index(4)", StarlarkInt.of(1))
+ .testExpression("[2, 4, 6].index(4)", StarlarkInt.of(1))
+ .testExpression("[0, 1, [1]].index([1])", StarlarkInt.of(2))
.testIfErrorContains("item \"a\" not found in list", "[1, 2].index('a')")
.testIfErrorContains("item 0 not found in list", "[].index(0)");
}
@@ -496,8 +496,8 @@
public void testHash() throws Exception {
// We specify the same string hashing algorithm as String.hashCode().
ev.new Scenario()
- .testExpression("hash('starlark')", "starlark".hashCode())
- .testExpression("hash('google')", "google".hashCode())
+ .testExpression("hash('starlark')", StarlarkInt.of("starlark".hashCode()))
+ .testExpression("hash('google')", StarlarkInt.of("google".hashCode()))
.testIfErrorContains(
"in call to hash(), parameter 'value' got value of type 'NoneType', want 'string'",
"hash(None)");
@@ -507,7 +507,7 @@
public void testRangeType() throws Exception {
ev.new Scenario()
.setUp("a = range(3)")
- .testExpression("len(a)", 3)
+ .testExpression("len(a)", StarlarkInt.of(3))
.testExpression("str(a)", "range(0, 3)")
.testExpression("str(range(1,2,3))", "range(1, 2, 3)")
.testExpression("repr(a)", "range(0, 3)")
@@ -529,11 +529,11 @@
.testExpression("str(list(range(5, 0, -1)))", "[5, 4, 3, 2, 1]")
.testExpression("str(list(range(5, 0, -10)))", "[5]")
.testExpression("str(list(range(0, -3, -2)))", "[0, -2]")
- .testExpression("range(3)[-1]", 2)
+ .testExpression("range(3)[-1]", StarlarkInt.of(2))
.testIfErrorContains(
"index out of range (index is 3, but sequence has 3 elements)", "range(3)[3]")
.testExpression("str(range(5)[1:])", "range(1, 5)")
- .testExpression("len(range(5)[1:])", 4)
+ .testExpression("len(range(5)[1:])", StarlarkInt.of(4))
.testExpression("str(range(5)[:2])", "range(0, 2)")
.testExpression("str(range(10)[1:9:2])", "range(1, 9, 2)")
.testExpression("str(list(range(10)[1:9:2]))", "[1, 3, 5, 7]")
@@ -600,17 +600,17 @@
@Test
public void testLenOnString() throws Exception {
- ev.new Scenario().testExpression("len('abc')", 3);
+ ev.new Scenario().testExpression("len('abc')", StarlarkInt.of(3));
}
@Test
public void testLenOnList() throws Exception {
- ev.new Scenario().testExpression("len([1,2,3])", 3);
+ ev.new Scenario().testExpression("len([1,2,3])", StarlarkInt.of(3));
}
@Test
public void testLenOnDict() throws Exception {
- ev.new Scenario().testExpression("len({'a' : 1, 'b' : 2})", 2);
+ ev.new Scenario().testExpression("len({'a' : 1, 'b' : 2})", StarlarkInt.of(2));
}
@Test
diff --git a/src/test/java/net/starlark/java/eval/PrinterTest.java b/src/test/java/net/starlark/java/eval/PrinterTest.java
index 4af6b61..e5accf4 100644
--- a/src/test/java/net/starlark/java/eval/PrinterTest.java
+++ b/src/test/java/net/starlark/java/eval/PrinterTest.java
@@ -85,10 +85,15 @@
@Test
public void testFormatPositional() throws Exception {
- assertThat(Starlark.formatWithList("%s %d", Tuple.of("foo", 3))).isEqualTo("foo 3");
- assertThat(Starlark.format("%s %d", "foo", 3)).isEqualTo("foo 3");
+ assertThat(Starlark.formatWithList("%s %d", Tuple.of("foo", StarlarkInt.of(3))))
+ .isEqualTo("foo 3");
+ assertThat(Starlark.format("%s %d", "foo", StarlarkInt.of(3))).isEqualTo("foo 3");
- assertThat(Starlark.format("%s %s %s", 1, null, 3)).isEqualTo("1 null 3");
+ // %d allows Integer or StarlarkInt
+ assertThat(Starlark.format("%d %d", StarlarkInt.of(123), 456)).isEqualTo("123 456");
+
+ assertThat(Starlark.format("%s %s %s", StarlarkInt.of(1), null, StarlarkInt.of(3)))
+ .isEqualTo("1 null 3");
// Note: formatToString doesn't perform scalar x -> (x) conversion;
// The %-operator is responsible for that.
@@ -102,11 +107,19 @@
"%%s", "foo");
checkFormatPositionalFails("unsupported format character \" \" at index 1 in \"% %s\"",
"% %s", "foo");
- assertThat(Starlark.format("%s", StarlarkList.of(null, 1, 2, 3))).isEqualTo("[1, 2, 3]");
- assertThat(Starlark.format("%s", Tuple.of(1, 2, 3))).isEqualTo("(1, 2, 3)");
+ assertThat(
+ Starlark.format(
+ "%s",
+ StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+ .isEqualTo("[1, 2, 3]");
+ assertThat(
+ Starlark.format(
+ "%s", Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3))))
+ .isEqualTo("(1, 2, 3)");
assertThat(Starlark.format("%s", StarlarkList.of(null))).isEqualTo("[]");
assertThat(Starlark.format("%s", Tuple.of())).isEqualTo("()");
- assertThat(Starlark.format("%% %d %r %s", 1, "2", "3")).isEqualTo("% 1 \"2\" 3");
+ assertThat(Starlark.format("%% %d %r %s", StarlarkInt.of(1), "2", "3"))
+ .isEqualTo("% 1 \"2\" 3");
checkFormatPositionalFails(
"invalid argument \"1\" for format pattern %d",
diff --git a/src/test/java/net/starlark/java/eval/ScriptTest.java b/src/test/java/net/starlark/java/eval/ScriptTest.java
index 8334c5b..0cce2e6 100644
--- a/src/test/java/net/starlark/java/eval/ScriptTest.java
+++ b/src/test/java/net/starlark/java/eval/ScriptTest.java
@@ -147,6 +147,10 @@
} catch (SyntaxError.Exception ex) {
// parser/resolver errors
for (SyntaxError err : ex.errors()) {
+ // TODO(adonovan): don't allow expectations to match static errors;
+ // they should be a different test suite. It is dangerous to mix
+ // them in a chunk otherwise the presence of a static error causes
+ // the program not to run the dynamic assertions.
if (!expected(expectations, err.message())) {
System.err.println(err); // includes location
ok = false;
diff --git a/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java b/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
index 3fd4160..d8e121b 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkEvaluationTest.java
@@ -454,6 +454,24 @@
throw new InternalError("buggy code");
}
+ @StarlarkMethod(
+ name = "int_conversion",
+ doc = "test implicit StarlarkInt to Integer conversion",
+ parameters = {
+ @Param(name = "a", type = Integer.class),
+ @Param(
+ name = "b",
+ allowedTypes = {
+ @ParamType(type = String.class),
+ @ParamType(type = Integer.class),
+ }),
+ @Param(name = "c"),
+ @Param(name = "d"),
+ })
+ public String intConversion(Object a, Object b, Integer c, Object d) {
+ return String.format("(%s, %s, %s, %s)", a, b, c, d);
+ }
+
@Override
public String toString() {
return "<mock>";
@@ -526,14 +544,14 @@
public void testSimpleIf() throws Exception {
ev.new Scenario()
.setUp("def foo():", " a = 0", " x = 0", " if x: a = 5", " return a", "a = foo()")
- .testLookup("a", 0);
+ .testLookup("a", StarlarkInt.of(0));
}
@Test
public void testIfPass() throws Exception {
ev.new Scenario()
.setUp("def foo():", " a = 1", " x = True", " if x: pass", " return a", "a = foo()")
- .testLookup("a", 1);
+ .testLookup("a", StarlarkInt.of(1));
}
@Test
@@ -558,7 +576,7 @@
" b = 3",
" return a + b",
"x = " + fun + "()")
- .testLookup("x", expected);
+ .testLookup("x", StarlarkInt.of(expected));
}
@Test
@@ -578,7 +596,7 @@
" else: a = 3",
" return a",
"z = " + fun + "()")
- .testLookup("z", expected);
+ .testLookup("z", StarlarkInt.of(expected));
}
@Test
@@ -609,7 +627,7 @@
" else:",
" return 3",
"v = foo()")
- .testLookup("v", v);
+ .testLookup("v", StarlarkInt.of(v));
}
@Test
@@ -848,7 +866,9 @@
" hit = 1",
" return [s, hit]",
"x = foo()");
- assertThat((Iterable<Object>) ev.lookup("x")).containsExactly(expected, 0).inOrder();
+ assertThat((Iterable<Object>) ev.lookup("x"))
+ .containsExactly(StarlarkInt.of(expected), StarlarkInt.of(0))
+ .inOrder();
}
@Test
@@ -873,7 +893,7 @@
" s = s + 1",
" return s",
"x = foo()");
- assertThat(ev.lookup("x")).isEqualTo(expected);
+ assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(expected));
}
private void flowFromNestedBlocks(String statement, int expected) throws Exception {
@@ -888,7 +908,7 @@
" s = s + 1",
" return s",
"y = foo2()");
- assertThat(ev.lookup("y")).isEqualTo(expected);
+ assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(expected));
}
@Test
@@ -924,7 +944,10 @@
" return [outer, first, second]",
"x = foo()");
assertThat((Iterable<Object>) ev.lookup("x"))
- .containsExactly(outerExpected, firstExpected, secondExpected)
+ .containsExactly(
+ StarlarkInt.of(outerExpected),
+ StarlarkInt.of(firstExpected),
+ StarlarkInt.of(secondExpected))
.inOrder();
}
@@ -970,7 +993,7 @@
public void testNoneAssignment() throws Exception {
ev.new Scenario()
.setUp("def foo(x=None):", " x = 1", " x = None", " return 2", "s = foo()")
- .testLookup("s", 2);
+ .testLookup("s", StarlarkInt.of(2));
}
@Test
@@ -1479,7 +1502,7 @@
public void testAugmentedAssignment() throws Exception {
ev.new Scenario()
.setUp("def f1(x):", " x += 1", " return x", "", "foo = f1(41)")
- .testLookup("foo", 42);
+ .testLookup("foo", StarlarkInt.of(42));
}
@Test
@@ -1495,7 +1518,7 @@
" return value",
"",
"f()[1] += 1") // `f()` should be called only once here
- .testLookup("counter", StarlarkList.of(null, 1));
+ .testLookup("counter", StarlarkList.of(null, StarlarkInt.of(1)));
// Check key position.
ev.new Scenario()
@@ -1508,7 +1531,7 @@
" return 1",
"",
"value[f()] += 1") // `f()` should be called only once here
- .testLookup("counter", StarlarkList.of(null, 1));
+ .testLookup("counter", StarlarkList.of(null, StarlarkInt.of(1)));
}
@Test
@@ -1607,7 +1630,12 @@
" t2 += (3, 4)",
" return t1, t2",
"tuples = func()")
- .testLookup("tuples", Tuple.of(Tuple.of(1, 2), Tuple.of(1, 2, 3, 4)));
+ .testLookup(
+ "tuples",
+ Tuple.of(
+ Tuple.of(StarlarkInt.of(1), StarlarkInt.of(2)),
+ Tuple.of(
+ StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3), StarlarkInt.of(4))));
}
@Test
@@ -1627,7 +1655,7 @@
public void testDictAssignmentAsLValue() throws Exception {
ev.new Scenario()
.setUp("def func():", " d = {'a' : 1}", " d['b'] = 2", " return d", "d = func()")
- .testLookup("d", ImmutableMap.of("a", 1, "b", 2));
+ .testLookup("d", ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
}
@Test
@@ -1640,7 +1668,9 @@
" e['d']['b'] = 2",
" return e",
"e = func()")
- .testLookup("e", ImmutableMap.of("d", ImmutableMap.of("a", 1, "b", 2)));
+ .testLookup(
+ "e",
+ ImmutableMap.of("d", ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2))));
}
@Test
@@ -1674,42 +1704,47 @@
ev.new Scenario()
.setUp(
"def func():", " d = {'a' : 1}", " d['b'], d['c'] = 2, 3", " return d", "d = func()")
- .testLookup("d", ImmutableMap.of("a", 1, "b", 2, "c", 3));
+ .testLookup(
+ "d",
+ ImmutableMap.of(
+ "a", StarlarkInt.of(1), "b", StarlarkInt.of(2), "c", StarlarkInt.of(3)));
}
@Test
public void testDictItemPlusEqual() throws Exception {
ev.new Scenario()
.setUp("def func():", " d = {'a' : 2}", " d['a'] += 3", " return d", "d = func()")
- .testLookup("d", ImmutableMap.of("a", 5));
+ .testLookup("d", ImmutableMap.of("a", StarlarkInt.of(5)));
}
@Test
public void testDictAssignmentAsLValueSideEffects() throws Exception {
ev.new Scenario()
.setUp("def func(d):", " d['b'] = 2", "d = {'a' : 1}", "func(d)")
- .testLookup("d", Dict.of((Mutability) null, "a", 1, "b", 2));
+ .testLookup(
+ "d", Dict.of((Mutability) null, "a", StarlarkInt.of(1), "b", StarlarkInt.of(2)));
}
@Test
public void testAssignmentToListInDictSideEffect() throws Exception {
ev.new Scenario()
.setUp("l = [1, 2]", "d = {0: l}", "d[0].append(3)")
- .testLookup("l", StarlarkList.of(null, 1, 2, 3));
+ .testLookup(
+ "l", StarlarkList.of(null, StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
}
@Test
public void testUserFunctionKeywordArgs() throws Exception {
ev.new Scenario()
.setUp("def foo(a, b, c):", " return a + b + c", "s = foo(1, c=2, b=3)")
- .testLookup("s", 6);
+ .testLookup("s", StarlarkInt.of(6));
}
@Test
public void testFunctionCallOrdering() throws Exception {
ev.new Scenario()
.setUp("def func(): return foo() * 2", "def foo(): return 2", "x = func()")
- .testLookup("x", 4);
+ .testLookup("x", StarlarkInt.of(4));
}
@Test
@@ -1733,7 +1768,7 @@
" else:",
" a = i",
"res = beforeEven([1, 3, 4, 5])")
- .testLookup("res", 3);
+ .testLookup("res", StarlarkInt.of(3));
}
@Test
@@ -1833,12 +1868,14 @@
@Test
public void testCannotCreateMixedListInStarlark() throws Exception {
- ev.new Scenario().testExactOrder("['a', 'b', 1, 2]", "a", "b", 1, 2);
+ ev.new Scenario()
+ .testExactOrder("['a', 'b', 1, 2]", "a", "b", StarlarkInt.of(1), StarlarkInt.of(2));
}
@Test
public void testCannotConcatListInStarlarkWithDifferentGenericTypes() throws Exception {
- ev.new Scenario().testExactOrder("[1, 2] + ['a', 'b']", 1, 2, "a", "b");
+ ev.new Scenario()
+ .testExactOrder("[1, 2] + ['a', 'b']", StarlarkInt.of(1), StarlarkInt.of(2), "a", "b");
}
@Test
@@ -1853,13 +1890,14 @@
@Test
public void testSingletonTuple() throws Exception {
- ev.new Scenario().testExactOrder("(1,)", 1);
+ ev.new Scenario().testExactOrder("(1,)", StarlarkInt.of(1));
}
@Test
public void testDirFindsClassObjectFields() throws Exception {
ev.new Scenario()
- .update("s", new SimpleStruct(ImmutableMap.of("a", 1, "b", 2)))
+ .update(
+ "s", new SimpleStruct(ImmutableMap.of("a", StarlarkInt.of(1), "b", StarlarkInt.of(2))))
.testExactOrder("dir(s)", "a", "b");
}
@@ -1870,6 +1908,7 @@
.testExactOrder(
"dir(mock)",
"function",
+ "int_conversion",
"interrupted_struct_field",
"is_empty",
"nullfunc_failing",
@@ -1918,14 +1957,14 @@
@Test
public void testConditionalExpressionAtToplevel() throws Exception {
- ev.new Scenario().setUp("x = 1 if 2 else 3").testLookup("x", 1);
+ ev.new Scenario().setUp("x = 1 if 2 else 3").testLookup("x", StarlarkInt.of(1));
}
@Test
public void testConditionalExpressionInFunction() throws Exception {
ev.new Scenario()
.setUp("def foo(a, b, c): return a+b if c else a-b\n")
- .testExpression("foo(23, 5, 0)", 18);
+ .testExpression("foo(23, 5, 0)", StarlarkInt.of(18));
}
// SimpleStructWithMethods augments SimpleStruct's fields with annotated Java methods.
@@ -2051,7 +2090,7 @@
" b = [a for a in range(3)]",
" return a",
"x = foo()");
- assertThat(ev.lookup("x")).isEqualTo(18);
+ assertThat(ev.lookup("x")).isEqualTo(StarlarkInt.of(18));
}
@Test
@@ -2062,7 +2101,7 @@
"def f():",
" return x",
"y = [f() for x in [2]][0]");
- assertThat(ev.lookup("y")).isEqualTo(1);
+ assertThat(ev.lookup("y")).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -2083,4 +2122,23 @@
() -> Starlark.addMethods(ImmutableMap.builder(), new Mock()));
assertThat(ex).hasMessageThat().contains("method struct_field has structField=true");
}
+
+ @Test
+ public void testIntegerReboxing() throws Exception {
+ ev.new Scenario()
+ .update("mock", new Mock())
+ .setUp("big = 111111111 * 111111111")
+ .testExpression("mock.int_conversion(1, 2, 3, 4)", "(1, 2, 3, 4)")
+ .testExpression("mock.int_conversion(1, 'b', 3, 'd')", "(1, b, 3, d)")
+ .testIfErrorContains(
+ "got 12345678987654321 for a, want value in signed 32-bit range",
+ "mock.int_conversion(big, 0, 0, 0)")
+ .testIfErrorContains(
+ "got 12345678987654321 for b, want value in signed 32-bit range",
+ "mock.int_conversion(0, big, 0, 0)")
+ .testIfErrorContains(
+ "got 12345678987654321 for c, want value in signed 32-bit range",
+ "mock.int_conversion(0, 0, big, 0)")
+ .testExpression("mock.int_conversion(0, 0, 0, big)", "(0, 0, 0, 12345678987654321)");
+ }
}
diff --git a/src/test/java/net/starlark/java/eval/StarlarkListTest.java b/src/test/java/net/starlark/java/eval/StarlarkListTest.java
index 17b3fbc..dd75283 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkListTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkListTest.java
@@ -33,14 +33,14 @@
@Test
public void testIndex() throws Exception {
ev.exec("l = [1, '2', 3]");
- assertThat(ev.eval("l[0]")).isEqualTo(1);
+ assertThat(ev.eval("l[0]")).isEqualTo(StarlarkInt.of(1));
assertThat(ev.eval("l[1]")).isEqualTo("2");
- assertThat(ev.eval("l[2]")).isEqualTo(3);
+ assertThat(ev.eval("l[2]")).isEqualTo(StarlarkInt.of(3));
ev.exec("t = (1, '2', 3)");
- assertThat(ev.eval("t[0]")).isEqualTo(1);
+ assertThat(ev.eval("t[0]")).isEqualTo(StarlarkInt.of(1));
assertThat(ev.eval("t[1]")).isEqualTo("2");
- assertThat(ev.eval("t[2]")).isEqualTo(3);
+ assertThat(ev.eval("t[2]")).isEqualTo(StarlarkInt.of(3));
}
@Test
@@ -145,19 +145,25 @@
@Test
public void testListSize() throws Exception {
- assertThat(ev.eval("len([42, 'hello, world', []])")).isEqualTo(3);
+ assertThat(ev.eval("len([42, 'hello, world', []])")).isEqualTo(StarlarkInt.of(3));
}
@Test
public void testListEmpty() throws Exception {
- assertThat(ev.eval("8 if [1, 2, 3] else 9")).isEqualTo(8);
- assertThat(ev.eval("8 if [] else 9")).isEqualTo(9);
+ assertThat(ev.eval("8 if [1, 2, 3] else 9")).isEqualTo(StarlarkInt.of(8));
+ assertThat(ev.eval("8 if [] else 9")).isEqualTo(StarlarkInt.of(9));
}
@Test
public void testListConcat() throws Exception {
assertThat(ev.eval("[1, 2] + [3, 4]"))
- .isEqualTo(StarlarkList.of(/*mutability=*/ null, 1, 2, 3, 4));
+ .isEqualTo(
+ StarlarkList.of(
+ /*mutability=*/ null,
+ StarlarkInt.of(1),
+ StarlarkInt.of(2),
+ StarlarkInt.of(3),
+ StarlarkInt.of(4)));
}
@Test
@@ -168,10 +174,10 @@
"e1 = l[1]",
"e2 = l[2]",
"e3 = l[3]");
- assertThat(ev.lookup("e0")).isEqualTo(1);
- assertThat(ev.lookup("e1")).isEqualTo(2);
- assertThat(ev.lookup("e2")).isEqualTo(3);
- assertThat(ev.lookup("e3")).isEqualTo(4);
+ assertThat(ev.lookup("e0")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("e1")).isEqualTo(StarlarkInt.of(2));
+ assertThat(ev.lookup("e2")).isEqualTo(StarlarkInt.of(3));
+ assertThat(ev.lookup("e3")).isEqualTo(StarlarkInt.of(4));
}
@Test
@@ -183,16 +189,16 @@
"e2 = l[2]",
"e3 = l[3]",
"e4 = l[4]");
- assertThat(ev.lookup("e0")).isEqualTo(1);
- assertThat(ev.lookup("e1")).isEqualTo(2);
- assertThat(ev.lookup("e2")).isEqualTo(3);
- assertThat(ev.lookup("e3")).isEqualTo(4);
- assertThat(ev.lookup("e4")).isEqualTo(5);
+ assertThat(ev.lookup("e0")).isEqualTo(StarlarkInt.of(1));
+ assertThat(ev.lookup("e1")).isEqualTo(StarlarkInt.of(2));
+ assertThat(ev.lookup("e2")).isEqualTo(StarlarkInt.of(3));
+ assertThat(ev.lookup("e3")).isEqualTo(StarlarkInt.of(4));
+ assertThat(ev.lookup("e4")).isEqualTo(StarlarkInt.of(5));
}
@Test
public void testConcatListSize() throws Exception {
- assertThat(ev.eval("len([1, 2] + [3, 4])")).isEqualTo(4);
+ assertThat(ev.eval("len([1, 2] + [3, 4])")).isEqualTo(StarlarkInt.of(4));
}
@Test
@@ -225,13 +231,13 @@
@Test
public void testConcatListNotEmpty() throws Exception {
ev.exec("l = [1, 2] + [3, 4]", "v = 1 if l else 0");
- assertThat(ev.lookup("v")).isEqualTo(1);
+ assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(1));
}
@Test
public void testConcatListEmpty() throws Exception {
ev.exec("l = [] + []", "v = 1 if l else 0");
- assertThat(ev.lookup("v")).isEqualTo(0);
+ assertThat(ev.lookup("v")).isEqualTo(StarlarkInt.of(0));
}
@Test
@@ -268,7 +274,9 @@
@Test
public void testMutatorsCheckMutability() throws Exception {
Mutability mutability = Mutability.create("test");
- StarlarkList<Object> list = StarlarkList.copyOf(mutability, ImmutableList.of(1, 2, 3));
+ StarlarkList<Object> list =
+ StarlarkList.copyOf(
+ mutability, ImmutableList.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
mutability.freeze();
// The casts force selection of the Starlark add/remove methods,
@@ -276,27 +284,37 @@
// We could enable the List method, but then it would have to
// report failures using unchecked exceptions.
EvalException e =
- assertThrows(EvalException.class, () -> list.add((Object) 4, (Location) null));
- assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
- e = assertThrows(EvalException.class, () -> list.add(0, (Object) 4, (Location) null));
+ assertThrows(
+ EvalException.class, () -> list.add((Object) StarlarkInt.of(4), (Location) null));
assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
e =
assertThrows(
- EvalException.class, () -> list.addAll(ImmutableList.of(4, 5, 6), (Location) null));
+ EvalException.class, () -> list.add(0, (Object) StarlarkInt.of(4), (Location) null));
+ assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
+ e =
+ assertThrows(
+ EvalException.class,
+ () ->
+ list.addAll(
+ ImmutableList.of(StarlarkInt.of(4), StarlarkInt.of(5), StarlarkInt.of(6)),
+ (Location) null));
assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
e = assertThrows(EvalException.class, () -> list.remove(0, (Location) null));
assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
- e = assertThrows(EvalException.class, () -> list.set(0, 10, (Location) null));
+ e = assertThrows(EvalException.class, () -> list.set(0, StarlarkInt.of(10), (Location) null));
assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
}
@Test
public void testCannotMutateAfterShallowFreeze() throws Exception {
Mutability mutability = Mutability.createAllowingShallowFreeze("test");
- StarlarkList<Object> list = StarlarkList.copyOf(mutability, ImmutableList.of(1, 2, 3));
+ StarlarkList<Object> list =
+ StarlarkList.copyOf(
+ mutability, ImmutableList.of(StarlarkInt.of(1), StarlarkInt.of(2), StarlarkInt.of(3)));
list.unsafeShallowFreeze();
- EvalException e = assertThrows(EvalException.class, () -> list.add((Object) 4, null));
+ EvalException e =
+ assertThrows(EvalException.class, () -> list.add((Object) StarlarkInt.of(4), null));
assertThat(e).hasMessageThat().isEqualTo("trying to mutate a frozen list value");
}
diff --git a/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java b/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
index effffb3..473b8f5 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkThreadDebuggingTest.java
@@ -213,11 +213,12 @@
@Test
public void testEvaluateVariableInScope() throws Exception {
- Module module = Module.withPredeclared(StarlarkSemantics.DEFAULT, ImmutableMap.of("a", 1));
+ Module module =
+ Module.withPredeclared(StarlarkSemantics.DEFAULT, ImmutableMap.of("a", StarlarkInt.of(1)));
StarlarkThread thread = newThread();
Object a = Starlark.execFile(ParserInput.fromLines("a"), FileOptions.DEFAULT, module, thread);
- assertThat(a).isEqualTo(1);
+ assertThat(a).isEqualTo(StarlarkInt.of(1));
}
@Test
@@ -247,6 +248,6 @@
.isEqualTo(true);
Starlark.execFile(ParserInput.fromLines("a = 1"), FileOptions.DEFAULT, module, thread);
assertThat(Starlark.execFile(ParserInput.fromLines("a"), FileOptions.DEFAULT, module, thread))
- .isEqualTo(1);
+ .isEqualTo(StarlarkInt.of(1));
}
}
diff --git a/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java b/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
index 3afd37c..5bb6ebd 100644
--- a/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
+++ b/src/test/java/net/starlark/java/eval/StarlarkThreadTest.java
@@ -41,10 +41,10 @@
@Test
public void testDoubleUpdateSucceeds() throws Exception {
assertThat(ev.lookup("VERSION")).isNull();
- ev.update("VERSION", 42);
- assertThat(ev.lookup("VERSION")).isEqualTo(42);
- ev.update("VERSION", 43);
- assertThat(ev.lookup("VERSION")).isEqualTo(43);
+ ev.update("VERSION", StarlarkInt.of(42));
+ assertThat(ev.lookup("VERSION")).isEqualTo(StarlarkInt.of(42));
+ ev.update("VERSION", StarlarkInt.of(43));
+ assertThat(ev.lookup("VERSION")).isEqualTo(StarlarkInt.of(43));
}
// Test assign through interpreter, ev.lookup through API:
@@ -87,7 +87,7 @@
StarlarkThread thread = new StarlarkThread(mu, StarlarkSemantics.DEFAULT);
Starlark.execFile(ParserInput.fromLines("True = 123"), FileOptions.DEFAULT, module, thread);
}
- assertThat(module.getGlobal("True")).isEqualTo(123);
+ assertThat(module.getGlobal("True")).isEqualTo(StarlarkInt.of(123));
}
@Test
diff --git a/src/test/java/net/starlark/java/eval/testdata/int.sky b/src/test/java/net/starlark/java/eval/testdata/int.sky
index 68d4877..e6b1680 100644
--- a/src/test/java/net/starlark/java/eval/testdata/int.sky
+++ b/src/test/java/net/starlark/java/eval/testdata/int.sky
@@ -7,10 +7,41 @@
assert_eq(5 * 7, 35)
assert_eq(5 - 7, -2)
+# big numbers (but no big literals yet)
+# TODO(adonovan): implement %x.
+assert_eq("%d" % (1 << 32), "4294967296") # ="0x100000000"
+assert_eq("%d" % (1 << 64), "18446744073709551616") # ="0x10000000000000000"
+assert_eq("%d" % (1 << 128), "340282366920938463463374607431768211456") # ="0x100000000000000000000000000000000"
+assert_eq("%d" % (-1 << 128), "-340282366920938463463374607431768211456") # ="-0x100000000000000000000000000000000"
+assert_eq((1 << 128) // (1 << 127), 2)
+
+# size boundaries
+maxint = (1<<31) - 1
+maxlong = (1<<63) - 1
+minint = -1 << 31
+minlong = -1 << 63
+assert_eq(str(maxint + 1), "2147483648")
+assert_eq(str(maxlong + 1), "9223372036854775808")
+assert_eq(str(minint - 1), "-2147483649")
+assert_eq(str(minlong - 1), "-9223372036854775809")
+
+# str(int)
+assert_eq(str(0), "0")
+assert_eq(str(1), "1")
+assert_eq(str(1<<24), "16777216")
+assert_eq(str(1<<48), "281474976710656")
+assert_eq(str(1<<96), "79228162514264337593543950336")
+assert_eq(str(-1<<24), "-16777216")
+assert_eq(str(-1<<48), "-281474976710656")
+assert_eq(str(-1<<96), "-79228162514264337593543950336")
+
# truth
-assert_(123)
-assert_(-1)
assert_(not 0)
+assert_(1)
+assert_(-1)
+assert_(1<<24) # int32
+assert_(1<<48) # int64
+assert_(1<<100) # big
# comparisons
assert_(5 > 2)
@@ -19,6 +50,31 @@
assert_(not (2 + 1 > 3))
assert_(2 + 2 <= 5)
assert_(not (2 + 1 < 3))
+big = 1 << 100
+assert_(big == big)
+assert_(not (big != big))
+assert_(big != big + 1)
+assert_(not (big == big + 1))
+assert_(big - 1 < big and big < big + 1)
+assert_(-big - 1 < -big and -big < -big + 1)
+
+# multiplication
+assert_eq(1111 * 1111, 1234321)
+assert_eq(1111 * 1, 1111)
+assert_eq(1111 * -1, -1111)
+assert_eq(1111 * 0, 0)
+p1, p2 = 0x316c5239, 0x67c4a7d5 # 32-bit primes
+product = p1 * p2
+assert_eq(product, p2 * p1)
+assert_eq(product // p1, p2)
+assert_eq(product % p1, 0)
+assert_eq(maxint, 0x7fffffff)
+assert_eq(str(maxint * maxint), "4611686014132420609")
+assert_eq(str((1<<62) - (2<<31) + 1), "4611686014132420609")
+assert_eq(str(111111111 * 111111111), "12345678987654321")
+assert_eq(str(-(111111111 * 111111111)), "-12345678987654321")
+assert_eq(str((111111111 * 111111111) // 111111111), "111111111")
+assert_eq(str((111111111 * 111111111) // 111111111), "111111111")
# division
assert_eq(100 // 7, 14)
@@ -29,6 +85,12 @@
assert_eq(98 // -7, -14)
assert_eq(-98 // 7, -14)
assert_eq(-98 // -7, 14)
+quot = 1169282 * 1000000 + 890553 # simplify when we have big literals
+assert_eq(product // 1234567, quot)
+assert_eq(product // -1234567, -quot-1)
+assert_eq(-product // 1234567, -quot-1)
+assert_eq(-product // -1234567, quot)
+assert_eq(((-1) << 31) // -1, 2147483647+1) # sole case of int // int that causes int overflow
# remainder
assert_eq(100 % 7, 2)
@@ -39,10 +101,17 @@
assert_eq(98 % -7, 0)
assert_eq(-98 % 7, 0)
assert_eq(-98 % -7, 0)
+assert_eq( product % 1234567, 1013598)
+assert_eq( product % -1234567, -220969) # ditto
+assert_eq(-product % 1234567, 220969) # ditto
+assert_eq(-product % -1234567, -1013598)
# precedence
assert_eq(5 - 7 * 2 + 3, -6)
assert_eq(4 * 5 // 2 + 5 // 2 * 4, 18)
+assert_eq(1<<8 - 1, 1 << (8-1)) # confusingly...
+assert_eq(8 | 3 ^ 4 & -2, 15)
+assert_eq(~8 >> 1 | 3 ^ 4 & -2 << 2 * 3 + 4 // -2, -5)
# compound assignment
def compound():
@@ -118,11 +187,14 @@
assert_eq(0 >> 0, 0)
assert_eq(1000 >> 100, 0)
assert_eq(-10 >> 1000, -1)
+assert_eq(1 << 500 >> 499, 2)
+assert_eq(1 << 32, 0x10000 * 0x10000)
+assert_eq(1 << 64, 0x10000 * 0x10000 * 0x10000 * 0x10000)
-# precedence
-
-assert_eq(8 | 3 ^ 4 & -2, 15)
-assert_eq(~8 >> 1 | 3 ^ 4 & -2 << 2 * 3 + 4 // -2, -5)
+assert_eq(((0x1010 << 100) | (0x1100 << 100)) >> 100, 0x1110)
+assert_eq(((0x1010 << 100) ^ (0x1100 << 100)) >> 100, 0x0110)
+assert_eq(((0x1010 << 100) & (0x1100 << 100)) >> 100, 0x1000)
+assert_eq(~((~(0x1010 << 100)) >> 100), 0x1010)
---
1 & False ### unsupported binary operation: int & bool
@@ -131,12 +203,8 @@
---
~False ### unsupported unary operation: ~bool
---
-1 << 31 ### integer overflow in left shift
----
-1 << 32 ### integer overflow in left shift
+1 << 520 ### shift count too large: 520
---
1 << -4 ### negative shift count: -4
---
2 >> -1 ### negative shift count: -1
----
-((-1) << 31) // -1 ### integer overflow in division
diff --git a/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky b/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
index 17eb1f8..abd5861 100644
--- a/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
+++ b/src/test/java/net/starlark/java/eval/testdata/int_constructor.sky
@@ -1,9 +1,50 @@
-assert_eq(int('1'), 1)
-assert_eq(int('-1234'), -1234)
+# Tests of int(x, [base])
+
+# from number
+assert_eq(int(0), 0)
assert_eq(int(42), 42)
assert_eq(int(-1), -1)
+assert_eq(int(2147483647), 2147483647)
+# -2147483648 is not (yet) a valid int literal even though it's a
+# valid int value, hence the -1 expression.
+assert_eq(int(-2147483647 - 1), -2147483647 - 1)
+---
+2147483648 ### invalid base-10 integer constant: 2147483648
+---
+-2147483649 ### invalid base-10 integer constant: 2147483649
+---
+
+# from bool
assert_eq(int(True), 1)
assert_eq(int(False), 0)
+
+# from other
+int(None) ### parameter 'x' cannot be None
+---
+
+# from string
+int('') ### empty string
+---
+# no base
+assert_eq(int('0'), 0)
+assert_eq(int('1'), 1)
+assert_eq(int('42'), 42)
+assert_eq(int('-1'), -1)
+assert_eq(int('-1234'), -1234)
+assert_eq(int('2147483647'), 2147483647)
+assert_eq(int('-2147483648'), -2147483647 - 1)
+assert_eq(int('123456789012345678901234567891234567890'), int('123456789012345678901234567891234567891') - 1)
+assert_eq(int('-123456789012345678901234567891234567890'), int('-123456789012345678901234567891234567891') + 1)
+assert_eq(int('-0xabcdefabcdefabcdefabcdefabcdef', 0), int('-892059645479943313385225296292859375'))
+assert_eq(int('1111111111111', 2), 8191)
+assert_eq(int('1111111111111', 5), int('305175781'))
+assert_eq(int('1111111111111', 8), int('78536544841'))
+assert_eq(int('1111111111111', 10), int('1111111111111'))
+assert_eq(int('1111111111111', 16), int('300239975158033'))
+assert_eq(int('1111111111111', 36), int('4873763662273663093'))
+assert_eq(int('016'), 16) # zero ok when base != 0.
+assert_eq(int('+42'), 42) # '+' prefix ok
+# with base, no prefix
assert_eq(int('11', 2), 3)
assert_eq(int('11', 9), 10)
assert_eq(int('AF', 16), 175)
@@ -11,34 +52,57 @@
assert_eq(int('az', 36), 395)
assert_eq(int('11', 10), 11)
assert_eq(int('11', 0), 11)
+# base and prefix
assert_eq(int('0b11', 0), 3)
assert_eq(int('0B11', 2), 3)
assert_eq(int('0o11', 0), 9)
assert_eq(int('0O11', 8), 9)
assert_eq(int('0XFF', 0), 255)
assert_eq(int('0xFF', 16), 255)
-
+assert_eq(int('0b11', 0), 3)
+assert_eq(int('-0b11', 0), -3)
+assert_eq(int('+0b11', 0), 3)
+assert_eq(int('0B11', 2), 3)
+assert_eq(int('0o11', 0), 9)
+assert_eq(int('0O11', 8), 9)
+assert_eq(int('-11', 2), -3)
+assert_eq(int('016', 8), 14)
+assert_eq(int('016', 16), 22)
+assert_eq(int('0', 0), 0)
+int('0xFF', 8) ### invalid base-8 literal: "0xFF"
---
-int('1.5') ### invalid literal for int\(\) with base 10
+int('016', 0) ### cannot infer base when string begins with a 0: "016"
---
-int('ab') ### invalid literal for int\(\) with base 10: "ab"
+int('123', 3) ### invalid base-3 literal: "123"
---
-int(None) ### parameter 'x' cannot be None
+int('FF', 15) ### invalid base-15 literal: "FF"
---
-int('123', 3) ### invalid literal for int\(\) with base 3: "123"
+int('123', -1) ### invalid base -1 (want 2 <= base <= 36)
---
-int('FF', 15) ### invalid literal for int\(\) with base 15: "FF"
+int('123', 1) ### invalid base 1 \(want 2 <= base <= 36\)
---
-int('123', -1) ### int\(\) base must be >= 2 and <= 36
+int('123', 37) ### invalid base 37 \(want 2 <= base <= 36\)
---
-int('123', 1) ### int\(\) base must be >= 2 and <= 36
+int('123', 'x') ### parameter 'base' got value of type 'string', want 'int'
---
-int('123', 37) ### int\(\) base must be >= 2 and <= 36
+int(True, 2) ### can't convert non-string with explicit base
---
-int('0xFF', 8) ### invalid literal for int\(\) with base 8: "0xFF"
+int(True, 10) ### can't convert non-string with explicit base
---
-int(True, 2) ### int\(\) can't convert non-string with explicit base
+int(1, 2) ### can't convert non-string with explicit base
---
-int(1, 2) ### int\(\) can't convert non-string with explicit base
+# This case is allowed in Python but not Skylark
+int() ### missing 1 required positional argument: x
---
-int(True, 10) ### int\(\) can't convert non-string with explicit base
+# Surrounding whitespace is not allowed
+int(' 42 ') ### invalid base-10 literal: " 42 "
+---
+int('-') ### invalid base-10 literal: "-"
+---
+int('+') ### invalid base-10 literal: "+"
+---
+int('0x') ### invalid base-10 literal: "0x"
+---
+int('1.5') ### invalid base-10 literal: "1.5"
+---
+int('ab') ### invalid base-10 literal: "ab"
diff --git a/src/test/java/net/starlark/java/eval/testdata/int_function.sky b/src/test/java/net/starlark/java/eval/testdata/int_function.sky
deleted file mode 100644
index ff72397..0000000
--- a/src/test/java/net/starlark/java/eval/testdata/int_function.sky
+++ /dev/null
@@ -1,95 +0,0 @@
-# int
-assert_eq(int(0), 0)
-assert_eq(int(42), 42)
-assert_eq(int(-1), -1)
-assert_eq(int(2147483647), 2147483647)
-# -2147483648 is not actually a valid int literal even though it's a
-# valid int value, hence the -1 expression.
-assert_eq(int(-2147483647 - 1), -2147483647 - 1)
-assert_eq(int(True), 1)
-assert_eq(int(False), 0)
-
----
-int(None) ### parameter 'x' cannot be None
----
-# This case is allowed in Python but not Skylark
-int() ### missing 1 required positional argument: x
----
-
-# string, no base
-# Includes same numbers as integer test cases above.
-assert_eq(int('0'), 0)
-assert_eq(int('42'), 42)
-assert_eq(int('-1'), -1)
-assert_eq(int('2147483647'), 2147483647)
-assert_eq(int('-2147483648'), -2147483647 - 1)
-# Leading zero allowed when not using base = 0.
-assert_eq(int('016'), 16)
-# Leading plus sign allowed for strings.
-assert_eq(int('+42'), 42)
-
----
-int(2147483648) ### invalid base-10 integer constant: 2147483648
----
-int(-2147483649) ### invalid base-10 integer constant: 2147483649
----
-int('') ### cannot be empty
----
-# Surrounding whitespace is not allowed
-int(' 42 ') ### invalid literal for int() with base 10: " 42 "
----
-int('-') ### invalid literal for int() with base 10: "-"
----
-int('0x') ### invalid literal for int() with base 10: "0x"
----
-int('1.5') ### invalid literal for int() with base 10: "1.5"
----
-int('ab') ### invalid literal for int() with base 10: "ab"
----
-
-assert_eq(int('11', 2), 3)
-assert_eq(int('-11', 2), -3)
-assert_eq(int('11', 9), 10)
-assert_eq(int('AF', 16), 175)
-assert_eq(int('11', 36), 37)
-assert_eq(int('az', 36), 395)
-assert_eq(int('11', 10), 11)
-assert_eq(int('11', 0), 11)
-assert_eq(int('016', 8), 14)
-assert_eq(int('016', 16), 22)
-
----
-# invalid base
-int('016', 0) ### cannot infer base for int() when value begins with a 0: "016"
----
-int('123', 3) ### invalid literal for int() with base 3: "123"
----
-int('FF', 15) ### invalid literal for int() with base 15: "FF"
----
-int('123', -1) ### int() base must be >= 2 and <= 36
----
-int('123', 1) ### int() base must be >= 2 and <= 36
----
-int('123', 37) ### int() base must be >= 2 and <= 36
----
-int('123', 'x') ### base must be an integer (got 'string')
----
-
-# base with prefix
-assert_eq(int('0b11', 0), 3)
-assert_eq(int('-0b11', 0), -3)
-assert_eq(int('+0b11', 0), 3)
-assert_eq(int('0B11', 2), 3)
-assert_eq(int('0o11', 0), 9)
-assert_eq(int('0O11', 8), 9)
-assert_eq(int('0XFF', 0), 255)
-assert_eq(int('0xFF', 16), 255)
-
----
-int('0xFF', 8) ### invalid literal for int() with base 8: "0xFF"
----
-int(True, 2) ### int() can't convert non-string with explicit base
----
-int(1, 2) ### int() can't convert non-string with explicit base
----
-int(True, 10) ### int() can't convert non-string with explicit base
