Last active
March 6, 2024 16:01
-
-
Save r2r-dev/6d73ab5d6bb00d085e5c5ed10b553dd9 to your computer and use it in GitHub Desktop.
java_starlark_repl
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| build --noenable_bzlmod --java_runtime_version=remotejdk_11 |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| From 73da039a634d93a92c90a85e7aade89a99527692 Mon Sep 17 00:00:00 2001 | |
| From: r2r r2r <[email protected]> | |
| Date: Wed, 6 Mar 2024 00:00:01 +0100 | |
| Subject: [PATCH] expose starlark as java_library target | |
| --- | |
| src/main/java/net/starlark/java/cmd/BUILD | 26 +++++++++++------------ | |
| 1 file changed, 13 insertions(+), 13 deletions(-) | |
| diff --git a/src/main/java/net/starlark/java/cmd/BUILD b/src/main/java/net/starlark/java/cmd/BUILD | |
| index 0ebe9e8..022f827 100644 | |
| --- a/src/main/java/net/starlark/java/cmd/BUILD | |
| +++ b/src/main/java/net/starlark/java/cmd/BUILD | |
| @@ -1,7 +1,7 @@ | |
| # The Starlark interpreter | |
| # Open-sourced as part of Bazel. | |
| -load("@rules_java//java:defs.bzl", "java_binary") | |
| +load("@rules_java//java:defs.bzl", "java_library") | |
| filegroup( | |
| name = "srcs", | |
| @@ -9,20 +9,20 @@ filegroup( | |
| visibility = ["//src:__subpackages__"], | |
| ) | |
| -java_binary( | |
| +java_library( | |
| name = "starlark", | |
| srcs = ["Main.java"], | |
| - jvm_flags = [ | |
| - # quiet warnings from com.google.protobuf.UnsafeUtil, | |
| - # see: https://github.com/google/protobuf/issues/3781 | |
| - # and: https://github.com/bazelbuild/bazel/issues/5599 | |
| - "--add-opens=java.base/java.nio=ALL-UNNAMED", | |
| - "--add-opens=java.base/java.lang=ALL-UNNAMED", | |
| - # ... but only on JDK >= 9 | |
| - "-XX:+IgnoreUnrecognizedVMOptions", | |
| - ], | |
| - main_class = "net.starlark.java.cmd.Main", | |
| - visibility = ["//src/main/java/net/starlark/java:clients"], | |
| + #jvm_flags = [ | |
| + # # quiet warnings from com.google.protobuf.UnsafeUtil, | |
| + # # see: https://github.com/google/protobuf/issues/3781 | |
| + # # and: https://github.com/bazelbuild/bazel/issues/5599 | |
| + # "--add-opens=java.base/java.nio=ALL-UNNAMED", | |
| + # "--add-opens=java.base/java.lang=ALL-UNNAMED", | |
| + # # ... but only on JDK >= 9 | |
| + # "-XX:+IgnoreUnrecognizedVMOptions", | |
| + #], | |
| + #main_class = "net.starlark.java.cmd.Main", | |
| + visibility = ["//visibility:public"], | |
| deps = [ | |
| "//src/main/java/net/starlark/java/eval", | |
| "//src/main/java/net/starlark/java/syntax", | |
| -- | |
| 2.34.1 |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # git clone https://github.com/bazelbuild/starlark.git | |
| # cat test_suite/testdata/java/*.star > all_tests.star | |
| # add preamble | |
| # remove all errors | |
| print("letsgo") | |
| def assert_eq(x, y): | |
| if x != y: | |
| print("%r != %r" % (x, y)) | |
| def assert_ne(x, y): | |
| if x == y: | |
| print("%r == %r" % (x, y)) | |
| def assert_(cond, msg="assertion failed"): | |
| if not cond: | |
| print(msg) | |
| # All with empty value | |
| assert_eq(all([]), True) | |
| # All with list | |
| assert_eq(all(['t', 'e']), True) | |
| assert_eq(all([False]), False) | |
| assert_eq(all([True, False]), False) | |
| assert_eq(all([False, False]), False) | |
| assert_eq(all([False, True]), False) | |
| assert_eq(all(['', True]), False) | |
| assert_eq(all([0, True]), False) | |
| assert_eq(all([[], True]), False) | |
| assert_eq(all([True, 't', 1]), True) | |
| # All with dict | |
| assert_eq(all({1 : None}), True) | |
| assert_eq(all({None : 1}), False) | |
| # Any with empty value | |
| assert_eq(any([]), False) | |
| # Any with list | |
| assert_eq(any([False]), False) | |
| assert_eq(any([0]), False) | |
| assert_eq(any(['']), False) | |
| assert_eq(any([[]]), False) | |
| assert_eq(any([True, False]), True) | |
| assert_eq(any([False, False]), False) | |
| assert_eq(any([False, '', 0]), False) | |
| assert_eq(any([False, '', 42]), True) | |
| # Any with dict | |
| assert_eq(any({1 : None, '' : None}), True) | |
| assert_eq(any({None : 1, '' : 2}), False) | |
| assert_eq(8 or 9, 8) | |
| assert_eq(0 or 9, 9) | |
| assert_eq(8 and 9, 9) | |
| assert_eq(0 and 9, 0) | |
| assert_eq(1 and 2 or 3, 2) | |
| assert_eq(0 and 2 or 3, 3) | |
| assert_eq(1 and 0 or 3, 3) | |
| assert_eq(1 or 2 and 3, 1) | |
| assert_eq(0 or 2 and 3, 3) | |
| assert_eq(0 or 0 and 3, 0) | |
| assert_eq(1 or 0 and 3, 1) | |
| assert_eq(None and 1, None) | |
| assert_eq("" or 9, 9) | |
| assert_eq("abc" or 9, "abc") | |
| # check that fail() is not evaluated | |
| assert_eq(8 or fail("do not execute"), 8) | |
| assert_eq(0 and fail("do not execute"), 0) | |
| assert_eq(not 1, False) | |
| assert_eq(not "", True) | |
| assert_eq(not not 1, True) | |
| assert_eq(not 0 + 0, True) | |
| assert_eq(not 2 - 1, False) | |
| assert_eq(not (0 and 0), True) | |
| assert_eq(not (1 or 0), False) | |
| assert_eq(0 and not 0, 0) | |
| assert_eq(not 0 and 0, 0) | |
| assert_eq(1 and not 0, True) | |
| assert_eq(not 0 or 0, True) | |
| assert_eq(not 1 or 0, 0) | |
| assert_eq(not 1 or 1, 1) | |
| assert_eq(not [], True) | |
| assert_eq(not {"a": 1}, False) | |
| # creation | |
| foo = {'a': 1, 'b': [1, 2]} | |
| bar = dict(a=1, b=[1, 2]) | |
| baz = dict({'a': 1, 'b': [1, 2]}) | |
| assert_eq(foo, bar) | |
| assert_eq(foo, baz) | |
| # get/setdefault | |
| assert_eq(foo.get('a'), 1) | |
| assert_eq(bar.get('b'), [1, 2]) | |
| assert_eq(baz.get('c'), None) | |
| assert_eq(baz.setdefault('c', 15), 15) | |
| assert_eq(baz.setdefault('c'), 15) | |
| assert_eq(baz.setdefault('c', 20), 15) | |
| assert_eq(baz.setdefault('d'), None) | |
| # items | |
| assert_eq(foo.items(), [('a', 1), ('b', [1, 2])]) | |
| # keys | |
| assert_eq(bar.keys(), ['a', 'b']) | |
| # values | |
| assert_eq(baz.values(), [1, [1, 2], 15, None]) | |
| # pop/popitem | |
| assert_eq(baz.pop('d'), None) | |
| assert_eq(foo.pop('a'), 1) | |
| assert_eq(bar.popitem(), ('a', 1)) | |
| assert_eq(foo, bar) | |
| assert_eq(foo.pop('a', 0), 0) | |
| assert_eq(foo.popitem(), ('b', [1, 2])) | |
| # update | |
| foo = dict() | |
| baz = dict(a=1, b=[1, 2]) | |
| bar = dict(b=[1, 2]) | |
| foo.update(baz) | |
| bar.update(a=1) | |
| baz.update({'c': 3}) | |
| foo.update([('c', 3)]) | |
| bar['c'] = 3 | |
| quz = dict() | |
| quz.update(bar.items()) | |
| assert_eq(foo, bar) | |
| assert_eq(foo, baz) | |
| assert_eq(foo, quz) | |
| d = {"b": 0} | |
| d.update({"a": 1}, b = 2) | |
| d.update({"c": 0}, c = 3, d = 4) | |
| d.update([("e", 5)]) | |
| # _inconsistency_: rust dict.update doesn't accept tuples | |
| # d.update((["f", 0],), f = 6) | |
| # expected = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6} | |
| expected = {"a": 1, "b": 2, "c": 3, "d": 4, "e": 5} | |
| assert_eq(d, expected) | |
| # creation with repeated keys | |
| d1 = dict([('a', 1)], a=2) | |
| d2 = dict({'a': 1}, a=2) | |
| d3 = dict([('a', 1), ('a', 2)]) | |
| assert_eq(d1['a'], 2) | |
| assert_eq(d1, d2) | |
| assert_eq(d1, d3) | |
| # == operator | |
| assert_eq(1 == 1, True) | |
| assert_eq(1 == 2, False) | |
| assert_eq('hello' == 'hel' + 'lo', True) | |
| assert_eq('hello' == 'bye', False) | |
| assert_eq(None == None, True) | |
| assert_eq([1, 2] == [1, 2], True) | |
| assert_eq([1, 2] == [2, 1], False) | |
| assert_eq({'a': 1, 'b': 2} == {'b': 2, 'a': 1}, True) | |
| assert_eq({'a': 1, 'b': 2} == {'a': 1}, False) | |
| assert_eq({'a': 1, 'b': 2} == {'a': 1, 'b': 2, 'c': 3}, False) | |
| assert_eq({'a': 1, 'b': 2} == {'a': 1, 'b': 3}, False) | |
| # != operator | |
| assert_eq(1 != 1, False) | |
| assert_eq(1 != 2, True) | |
| assert_eq('hello' != 'hel' + 'lo', False) | |
| assert_eq('hello' != 'bye', True) | |
| assert_eq([1, 2] != [1, 2], False) | |
| assert_eq([1, 2] != [2, 1], True) | |
| assert_eq({'a': 1, 'b': 2} != {'b': 2, 'a': 1}, False) | |
| assert_eq({'a': 1, 'b': 2} != {'a': 1}, True) | |
| assert_eq({'a': 1, 'b': 2} != {'a': 1, 'b': 2, 'c': 3}, True) | |
| assert_eq({'a': 1, 'b': 2} != {'a': 1, 'b': 3}, True); | |
| # equality precedence | |
| assert_eq(1 + 3 == 2 + 2, True) | |
| assert_eq(not 1 == 2, True) | |
| assert_eq(not 1 != 2, False) | |
| assert_eq(2 and 3 == 3 or 1, True) | |
| assert_eq(2 or 3 == 3 and 1, 2); | |
| # < operator | |
| assert_eq(1 <= 1, True) | |
| assert_eq(1 < 1, False) | |
| assert_eq('a' <= 'b', True) | |
| assert_eq('c' < 'a', False); | |
| # <= and < operators | |
| assert_eq(1 <= 1, True) | |
| assert_eq(1 < 1, False) | |
| assert_eq('a' <= 'b', True) | |
| assert_eq('c' < 'a', False); | |
| # >= and > operators | |
| assert_eq(1 >= 1, True) | |
| assert_eq(1 > 1, False) | |
| assert_eq('a' >= 'b', False) | |
| assert_eq('c' > 'a', True); | |
| # list/tuple comparison | |
| assert_eq([] < [1], True) | |
| assert_eq([1] < [1, 1], True) | |
| assert_eq([1, 1] < [1, 2], True) | |
| assert_eq([1, 2] < [1, 2, 3], True) | |
| assert_eq([1, 2, 3] <= [1, 2, 3], True) | |
| assert_eq(['a', 'b'] > ['a'], True) | |
| assert_eq(['a', 'b'] >= ['a'], True) | |
| assert_eq(['a', 'b'] < ['a'], False) | |
| assert_eq(['a', 'b'] <= ['a'], False) | |
| assert_eq(('a', 'b') > ('a', 'b'), False) | |
| assert_eq(('a', 'b') >= ('a', 'b'), True) | |
| assert_eq(('a', 'b') < ('a', 'b'), False) | |
| assert_eq(('a', 'b') <= ('a', 'b'), True) | |
| assert_eq([[1, 1]] > [[1, 1], []], False) | |
| assert_eq([[1, 1]] < [[1, 1], []], True) | |
| # Tests of Skylark 'int' | |
| # basic arithmetic | |
| assert_eq(0 - 1, -1) | |
| assert_eq(1 + 1, 2) | |
| assert_eq(5 + 7, 12) | |
| assert_eq(5 * 7, 35) | |
| assert_eq(5 - 7, -2) | |
| # truth | |
| assert_(123) | |
| assert_(-1) | |
| assert_(not 0) | |
| # comparisons | |
| assert_(5 > 2) | |
| assert_(2 + 1 == 3) | |
| assert_(2 + 1 >= 3) | |
| assert_(not (2 + 1 > 3)) | |
| assert_(2 + 2 <= 5) | |
| assert_(not (2 + 1 < 3)) | |
| # division | |
| assert_eq(100 // 7, 14) | |
| assert_eq(100 // -7, -15) | |
| assert_eq(-100 // 7, -15) # NB: different from Go / Java | |
| assert_eq(-100 // -7, 14) # NB: different from Go / Java | |
| assert_eq(98 // 7, 14) | |
| assert_eq(98 // -7, -14) | |
| assert_eq(-98 // 7, -14) | |
| assert_eq(-98 // -7, 14) | |
| # remainder | |
| assert_eq(100 % 7, 2) | |
| assert_eq(100 % -7, -5) # NB: different from Go / Java | |
| assert_eq(-100 % 7, 5) # NB: different from Go / Java | |
| assert_eq(-100 % -7, -2) | |
| assert_eq(98 % 7, 0) | |
| assert_eq(98 % -7, 0) | |
| assert_eq(-98 % 7, 0) | |
| assert_eq(-98 % -7, 0) | |
| # precedence | |
| assert_eq(5 - 7 * 2 + 3, -6) | |
| assert_eq(4 * 5 // 2 + 5 // 2 * 4, 18) | |
| # compound assignment | |
| def compound(): | |
| x = 1 | |
| x += 1 | |
| assert_eq(x, 2) | |
| x -= 3 | |
| assert_eq(x, -1) | |
| x *= 10 | |
| assert_eq(x, -10) | |
| x //= -2 | |
| assert_eq(x, 5) | |
| x %= 3 | |
| assert_eq(x, 2) | |
| compound() | |
| assert_eq(int('1'), 1) | |
| assert_eq(int('-1234'), -1234) | |
| assert_eq(int(42), 42) | |
| assert_eq(int(-1), -1) | |
| assert_eq(int(True), 1) | |
| assert_eq(int(False), 0) | |
| 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('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 | |
| assert_eq(int(0), 0) | |
| assert_eq(int(42), 42) | |
| assert_eq(int(-1), -1) | |
| assert_eq(int(2147483647), 2147483647) | |
| # _inconsistency_: rust doesn't allow -2147483648 as an int value | |
| # -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) | |
| # _inconsistency_: rust allows int() without an argument | |
| # This case is allowed in Python but not Skylark | |
| # int() ## (required positional argument|not enough parameters|missing argument) | |
| # 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) | |
| # _inconsistency_: rust doesn't allow -2147483648 as an int value | |
| # 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) | |
| # _inconsistency_: go, rust allow 64-bit ints | |
| # int(2147483648) ## invalid base-10 integer constant: 2147483648 | |
| # int(-2147483649) ## invalid base-10 integer constant: 2147483649 | |
| 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) | |
| # _inconsistency_: rust doesn't complain about this | |
| # invalid base | |
| # int('016', 0) ## base.*016 | |
| # 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) | |
| foo = ['a', 'b'] | |
| foo.insert(0, 'c') | |
| assert_eq(foo, ['c', 'a', 'b']) | |
| foo.insert(1, 'd') | |
| assert_eq(foo, ['c', 'd', 'a', 'b']) | |
| foo.insert(4, 'e') | |
| assert_eq(foo, ['c', 'd', 'a', 'b', 'e']) | |
| foo.insert(-10, 'f') | |
| assert_eq(foo, ['f', 'c', 'd', 'a', 'b', 'e']) | |
| foo.insert(10, 'g') | |
| assert_eq(foo, ['f', 'c', 'd', 'a', 'b', 'e', 'g']) | |
| # append | |
| foo = ['a', 'b'] | |
| foo.append('c') | |
| assert_eq(foo, ['a', 'b', 'c']) | |
| foo.append('d') | |
| assert_eq(foo, ['a', 'b', 'c', 'd']) | |
| # extend | |
| foo = ['a', 'b'] | |
| foo.extend(['c', 'd']) | |
| foo.extend(('e', 'f')) | |
| assert_eq(foo, ['a', 'b', 'c', 'd', 'e', 'f']) | |
| # remove | |
| foo = ['a', 'b', 'c', 'b'] | |
| foo.remove('b') | |
| assert_eq(foo, ['a', 'c', 'b']) | |
| foo.remove('c') | |
| assert_eq(foo, ['a', 'b']) | |
| foo.remove('a') | |
| assert_eq(foo, ['b']) | |
| foo.remove('b') | |
| assert_eq(foo, []) | |
| # pop | |
| li1 = [2, 3, 4] | |
| assert_eq(li1.pop(), 4) | |
| assert_eq(li1, [2, 3]) | |
| li2 = [2, 4] | |
| #li2 = [2, 3, 4] | |
| # _inconsistency_: rust pop() method doesn't support -ve indices | |
| # assert_eq(li2.pop(-2), 3) | |
| assert_eq(li2, [2, 4]) | |
| li3 = [2, 3, 4] | |
| assert_eq(li3.pop(1), 3) | |
| assert_eq(li3, [2, 4]) | |
| # Without step | |
| assert_eq([0, 1, 2, 3][0:-1], [0, 1, 2]) | |
| assert_eq([0, 1, 2, 3, 4, 5][2:4], [2, 3]) | |
| assert_eq([0, 1, 2, 3, 4, 5][-2:-1], [4]) | |
| assert_eq([][1:2], []) | |
| assert_eq([0, 1, 2, 3][-10:10], [0, 1, 2, 3]) | |
| # With step | |
| assert_eq([1, 2, 3, 4, 5][::1], [1, 2, 3, 4, 5]) | |
| assert_eq([1, 2, 3, 4, 5][1::1], [2, 3, 4, 5]) | |
| assert_eq([1, 2, 3, 4, 5][:2:1], [1, 2]) | |
| assert_eq([1, 2, 3, 4, 5][1:3:1], [2, 3]) | |
| assert_eq([1, 2, 3, 4, 5][-4:-2:1], [2, 3]) | |
| assert_eq([1, 2, 3, 4, 5][-10:10:1], [1, 2, 3, 4, 5]) | |
| assert_eq([1, 2, 3, 4, 5][::42], [1]) | |
| assert_eq([][::1], []) | |
| assert_eq([][::-1], []) | |
| assert_eq([1, 2, 3, 4, 5, 6, 7][::3], [1, 4, 7]) | |
| assert_eq([1, 2, 3, 4, 5, 6, 7, 8, 9][1:7:3], [2, 5]) | |
| assert_eq([1, 2, 3][3:1:1], []) | |
| assert_eq([1, 2, 3][1:3:-1], []) | |
| # Negative step | |
| assert_eq([1, 2, 3, 4, 5][::-1], [5, 4, 3, 2, 1]) | |
| assert_eq([1, 2, 3, 4, 5][4::-1], [5, 4, 3, 2, 1]) | |
| assert_eq([1, 2, 3, 4, 5][:0:-1], [5, 4, 3, 2]) | |
| assert_eq([1, 2, 3, 4, 5][3:1:-1], [4, 3]) | |
| assert_eq([1, 2, 3, 4, 5][::-2], [5, 3, 1]) | |
| assert_eq([1, 2, 3, 4, 5][::-10], [5]) | |
| # None | |
| assert_eq([1, 2, 3][None:None:None], [1, 2, 3]) | |
| assert_eq([1, 2, 3][None:None], [1, 2, 3]) | |
| assert_eq([1, 2, 3][None:2:None], [1, 2]) | |
| # Tuples | |
| assert_eq(()[1:2], ()) | |
| assert_eq(()[::1], ()) | |
| assert_eq((0, 1, 2, 3)[0:-1], (0, 1, 2)) | |
| assert_eq((0, 1, 2, 3, 4, 5)[2:4], (2, 3)) | |
| assert_eq((0, 1, 2, 3)[-10:10], (0, 1, 2, 3)) | |
| assert_eq((1, 2, 3, 4, 5)[-10:10:1], (1, 2, 3, 4, 5)) | |
| assert_eq((1, 2, 3, 4, 5, 6, 7, 8, 9)[1:7:3], (2, 5)) | |
| assert_eq((1, 2, 3, 4, 5)[::-1], (5, 4, 3, 2, 1)) | |
| assert_eq((1, 2, 3, 4, 5)[3:1:-1], (4, 3)) | |
| assert_eq((1, 2, 3, 4, 5)[::-2], (5, 3, 1)) | |
| assert_eq((1, 2, 3, 4, 5)[::-10], (5,)) | |
| # index | |
| assert_eq(['a', 'b', 'c', 'd'][0], 'a') | |
| assert_eq(['a', 'b', 'c', 'd'][1], 'b') | |
| assert_eq(['a', 'b', 'c', 'd'][-1], 'd') | |
| assert_eq(['a', 'b', 'c', 'd'][-2], 'c') | |
| assert_eq([0, 1, 2][-3], 0) | |
| assert_eq([0, 1, 2][-2], 1) | |
| assert_eq([0, 1, 2][-1], 2) | |
| assert_eq([0, 1, 2][0], 0) | |
| # min / max | |
| # _inconsistency_: rust elems() returns list of ints | |
| # assert_eq(min("abcdefxyz".elems()), "a") | |
| assert_eq(min("test", "xyz"), "test") | |
| assert_eq(min([4, 5], [1]), [1]) | |
| assert_eq(min([1, 2], [3]), [1, 2]) | |
| assert_eq(min([1, 5], [1, 6], [2, 4], [0, 6]), [0, 6]) | |
| assert_eq(min([-1]), -1) | |
| assert_eq(min([5, 2, 3]), 2) | |
| assert_eq(min({1: 2, -1 : 3}), -1) | |
| assert_eq(min({2: None}), 2) | |
| assert_eq(min(-1, 2), -1) | |
| assert_eq(min(5, 2, 3), 2) | |
| assert_eq(min(1, 1, 1, 1, 1, 1), 1) | |
| assert_eq(min([1, 1, 1, 1, 1, 1]), 1) | |
| # _inconsistency_: rust elems() returns list of ints | |
| # assert_eq(max("abcdefxyz".elems()), "z") | |
| assert_eq(max("test", "xyz"), "xyz") | |
| assert_eq(max("test", "xyz"), "xyz") | |
| assert_eq(max([1, 2], [5]), [5]) | |
| assert_eq(max([-1]), -1) | |
| assert_eq(max([5, 2, 3]), 5) | |
| assert_eq(max({1: 2, -1 : 3}), 1) | |
| assert_eq(max({2: None}), 2) | |
| assert_eq(max(-1, 2), 2) | |
| assert_eq(max(5, 2, 3), 5) | |
| assert_eq(max(1, 1, 1, 1, 1, 1), 1) | |
| assert_eq(max([1, 1, 1, 1, 1, 1]), 1) | |
| # _inconsistency_: rust supports comparision between ints and strings | |
| # min(1, "2", True) ## (Cannot compare int with string|not implemented) | |
| # min([1, "2", True]) ## (Cannot compare int with string|not implemented) | |
| # max(1, '2', True) ## (Cannot compare int with string|not implemented) | |
| # max([1, '2', True]) ## (Cannot compare int with string|not implemented) | |
| assert_eq(list(range(5)), [0, 1, 2, 3, 4]) | |
| assert_eq(list(range(0)), []) | |
| assert_eq(list(range(1)), [0]) | |
| assert_eq(list(range(-2)), []) | |
| assert_eq(list(range(-3, 2)), [-3, -2, -1, 0, 1]) | |
| assert_eq(list(range(3, 2)), []) | |
| assert_eq(list(range(3, 3)), []) | |
| assert_eq(list(range(3, 4)), [3]) | |
| assert_eq(list(range(3, 5)), [3, 4]) | |
| assert_eq(list(range(-3, 5, 2)), [-3, -1, 1, 3]) | |
| assert_eq(list(range(-3, 6, 2)), [-3, -1, 1, 3, 5]) | |
| assert_eq(list(range(5, 0, -1)), [5, 4, 3, 2, 1]) | |
| assert_eq(list(range(5, 0, -10)), [5]) | |
| assert_eq(list(range(0, -3, -2)), [0, -2]) | |
| # lists | |
| assert_eq(reversed([]), []) | |
| # _inconsistency_: rust returns list of ints | |
| # assert_eq(reversed('a'.elems()), ['a']) | |
| # assert_eq(reversed('abc'.elems()), ['c', 'b', 'a']) | |
| # assert_eq(reversed('__test '.elems()), [' ', ' ', 't', 's', 'e', 't', '_', '_']) | |
| # assert_eq(reversed('bbb'.elems()), ['b', 'b', 'b']) | |
| # _inconsistency_: go, rust reversed() accepts dict as argument | |
| # reversed({1: 3}) ## Argument to reversed() must be a sequence, not a dictionary | |
| x = ['a', 'b'] | |
| y = reversed(x) | |
| y.append('c') | |
| assert_eq(y, ['b', 'a', 'c']) | |
| assert_eq(x, ['a', 'b']) | |
| def reverse_equivalence(inp): | |
| assert_eq(reversed(inp), inp[::-1]) | |
| assert_eq(reversed(reversed(inp)), inp) | |
| reverse_equivalence([]) | |
| reverse_equivalence([1]) | |
| reverse_equivalence(["a", "b"]) | |
| # _inconsistency_: rust elems() returns list of ints | |
| # string.elems | |
| # assert_eq(list("abcd".elems()), ["a", "b", "c", "d"]) | |
| # assert_eq(len("aaa".elems()), 3) | |
| def test_iter(): | |
| i = 0 | |
| for c in "abcd".elems(): | |
| assert_eq(c, "abcd"[i]) | |
| i += 1 | |
| assert_eq(i, 4) | |
| # test_iter() | |
| assert_eq('banana'.find('na'), 2) | |
| assert_eq('banana'.find('na', 3, 1), -1) | |
| assert_eq('aaaa'.find('a', 1, 1), -1) | |
| assert_eq('aaaa'.find('a', 1, 50), 1) | |
| assert_eq('aaaa'.find('aaaaa'), -1) | |
| assert_eq('abababa'.find('ab', 1), 2) | |
| assert_eq('abababa'.find('ab', 0), 0) | |
| assert_eq('abababa'.find('ab', -1), -1) | |
| assert_eq('abababa'.find('ab', -2), -1) | |
| assert_eq('abababa'.find('ab', -3), 4) | |
| assert_eq('abababa'.find('ab', 0, 1), -1) | |
| assert_eq('abababa'.find('ab', 0, 2), 0) | |
| assert_eq('abababa'.find('ab', -1000), 0) | |
| assert_eq('abababa'.find('ab', 1000), -1) | |
| assert_eq(''.find('a', 1), -1) | |
| assert_eq('banana'.rfind('na'), 4) | |
| assert_eq('banana'.rfind('na', 3, 1), -1) | |
| assert_eq('aaaa'.rfind('a', 1, 1), -1) | |
| assert_eq('aaaa'.rfind('a', 1, 50), 3) | |
| assert_eq('aaaa'.rfind('aaaaa'), -1) | |
| assert_eq('abababa'.rfind('ab', 1), 4) | |
| assert_eq('abababa'.rfind('ab', 0), 4) | |
| assert_eq('abababa'.rfind('ab', -1), -1) | |
| assert_eq('abababa'.rfind('ab', -2), -1) | |
| assert_eq('abababa'.rfind('ab', -3), 4) | |
| assert_eq('abababa'.rfind('ab', 0, 1), -1) | |
| assert_eq('abababa'.rfind('ab', 0, 2), 0) | |
| assert_eq('abababa'.rfind('ab', -1000), 4) | |
| assert_eq('abababa'.rfind('ab', 1000), -1) | |
| assert_eq(''.rfind('a', 1), -1) | |
| assert_eq('abc'.format(), "abc") | |
| # named arguments | |
| assert_eq('x{key}x'.format(key = 2), "x2x") | |
| assert_eq('x{key}x'.format(key = 'abc'), "xabcx") | |
| assert_eq('{a}{b}{a}{b}'.format(a = 3, b = True), "3True3True") | |
| assert_eq('{a}{b}{a}{b}'.format(a = 3, b = True), "3True3True") | |
| assert_eq('{s1}{s2}'.format(s1 = ['a'], s2 = 'a'), "[\"a\"]a") | |
| assert_eq('{a}'.format(a = '$'), "$") | |
| assert_eq('{a}'.format(a = '$a'), "$a") | |
| assert_eq('{a}$'.format(a = '$a'), "$a$") | |
| assert_eq('{(}'.format(**{'(': 2}), "2") | |
| # curly brace escaping | |
| assert_eq('{{}}'.format(), "{}") | |
| assert_eq('{{}}'.format(42), "{}") | |
| assert_eq('{{ }}'.format(), "{ }") | |
| assert_eq('{{ }}'.format(42), "{ }") | |
| assert_eq('{{{{}}}}'.format(), "{{}}") | |
| assert_eq('{{{{}}}}'.format(42), "{{}}") | |
| assert_eq('{{0}}'.format(42), "{0}") | |
| assert_eq('{{}}'.format(42), "{}") | |
| assert_eq('{{{}}}'.format(42), "{42}") | |
| assert_eq('{{ '.format(42), "{ " ) | |
| assert_eq(' }}'.format(42), " }") | |
| assert_eq('{{ {}'.format(42), "{ 42") | |
| assert_eq('{} }}'.format(42), "42 }") | |
| assert_eq('{{0}}'.format(42), "{0}") | |
| assert_eq('{{{0}}}'.format(42), "{42}") | |
| assert_eq('{{ 0'.format(42), "{ 0") | |
| assert_eq('0 }}'.format(42), "0 }") | |
| assert_eq('{{ {0}'.format(42), "{ 42") | |
| assert_eq('{0} }}'.format(42), "42 }") | |
| assert_eq('{{test}}'.format(test = 42), "{test}") | |
| assert_eq('{{{test}}}'.format(test = 42), "{42}") | |
| assert_eq('{{ test'.format(test = 42), "{ test") | |
| assert_eq('test }}'.format(test = 42), "test }") | |
| assert_eq('{{ {test}'.format(test = 42), "{ 42") | |
| assert_eq('{test} }}'.format(test = 42), "42 }") | |
| # Automatic positionals | |
| assert_eq('{}, {} {} {} test'.format('hi', 'this', 'is', 'a'), "hi, this is a test") | |
| assert_eq('skip some {}'.format('arguments', 'obsolete', 'deprecated'), "skip some arguments") | |
| # with numbered positions | |
| assert_eq('{0}, {1} {2} {3} test'.format('hi', 'this', 'is', 'a'), "hi, this is a test") | |
| assert_eq('{3}, {2} {1} {0} test'.format('a', 'is', 'this', 'hi'), "hi, this is a test") | |
| assert_eq('skip some {0}'.format('arguments', 'obsolete', 'deprecated'), "skip some arguments") | |
| assert_eq('{0} can be reused: {0}'.format('this', 'obsolete'), "this can be reused: this") | |
| # Mixed fields | |
| assert_eq('{test} and {}'.format(2, test = 1), "1 and 2") | |
| assert_eq('{test} and {0}'.format(2, test = 1), "1 and 2") | |
| # _inconsistency_: -0 not allowed in go,rust, different error | |
| # '{-0} and {-1}'.format('this', 'that') ## | |
| # join | |
| assert_eq('-'.join(['a', 'b', 'c']), "a-b-c") | |
| assert_eq(''.join([(x + '*') for x in ['a', 'b', 'c']]), "a*b*c*") | |
| li = [(y + '*' + z + '|') for y in ['a', 'b', 'c'] for z in ['d', 'e']] | |
| assert_eq(''.join(li), "a*d|a*e|b*d|b*e|c*d|c*e|") | |
| # lower, upper | |
| assert_eq('Blah Blah'.lower(), "blah blah") | |
| assert_eq('ein bier'.upper(), "EIN BIER") | |
| assert_eq(''.upper(), "") | |
| # title | |
| assert_eq('this is a very simple test'.title(), "This Is A Very Simple Test") | |
| assert_eq('Do We Keep Capital Letters?'.title(), "Do We Keep Capital Letters?") | |
| assert_eq("this isn't just an ol' apostrophe test".title(), | |
| "This Isn'T Just An Ol' Apostrophe Test") | |
| assert_eq('Let us test crazy characters: _bla.exe//foo:bla(test$class)'.title(), | |
| "Let Us Test Crazy Characters: _Bla.Exe//Foo:Bla(Test$Class)") | |
| assert_eq('WE HAve tO lOWERCASE soMEthING heRE, AI?'.title(), | |
| "We Have To Lowercase Something Here, Ai?") | |
| assert_eq('wh4t ab0ut s0me numb3rs'.title(), "Wh4T Ab0Ut S0Me Numb3Rs") | |
| # _inconsistency_: rust's capitalize() implementation is different from go, java | |
| # capitalize | |
| # assert_eq('hello world'.capitalize(), "Hello world") | |
| # assert_eq('HELLO WORLD'.capitalize(), "Hello world") | |
| # assert_eq('12 lower UPPER 34'.capitalize(), "12 lower upper 34") | |
| assert_eq(''.capitalize(), "") | |
| # replace | |
| assert_eq('banana'.replace('a', 'e'), "benene") | |
| assert_eq('banana'.replace('a', '$()'), "b$()n$()n$()") | |
| assert_eq('banana'.replace('a', '$'), "b$n$n$") | |
| assert_eq('banana'.replace('a', '\\'), "b\\n\\n\\") | |
| assert_eq('b$()n$()n$()'.replace('$()', '$($())'), "b$($())n$($())n$($())") | |
| assert_eq('b\\n\\n\\'.replace('\\', '$()'), "b$()n$()n$()") | |
| assert_eq('banana'.replace('a', 'e', 2), "benena") | |
| # index, rindex | |
| assert_eq('banana'.index('na'), 2) | |
| assert_eq('abababa'.index('ab', 1), 2) | |
| assert_eq('banana'.rindex('na'), 4) | |
| assert_eq('abababa'.rindex('ab', 1), 4) | |
| # endswith | |
| assert_eq('Apricot'.endswith('cot'), True) | |
| assert_eq('a'.endswith(''), True) | |
| assert_eq(''.endswith(''), True) | |
| assert_eq('Apricot'.endswith('co'), False) | |
| # _inconsistency_: rust endswith() accepts only one parameter | |
| # assert_eq('Apricot'.endswith('co', -1), False) | |
| # assert_eq('abcd'.endswith('c', -2, -1), True) | |
| # assert_eq('abcd'.endswith('c', 1, 8), False) | |
| # assert_eq('abcd'.endswith('d', 1, 8), True) | |
| assert_eq('Apricot'.endswith(('cot', 'toc')), True) | |
| assert_eq('Apricot'.endswith(('toc', 'cot')), True) | |
| assert_eq('a'.endswith(('', '')), True) | |
| assert_eq('a'.endswith(('', 'a')), True) | |
| assert_eq('a'.endswith(('a', 'a')), True) | |
| assert_eq(''.endswith(('a', '')), True) | |
| assert_eq(''.endswith(('', '')), True) | |
| assert_eq(''.endswith(('a', 'a')), False) | |
| assert_eq('a'.endswith(('a')), True) | |
| assert_eq('a'.endswith(('a',)), True) | |
| assert_eq('a'.endswith(('b',)), False) | |
| assert_eq('a'.endswith(()), False) | |
| assert_eq(''.endswith(()), False) | |
| # _inconsistency_: rust endswith() accepts a list (not just a tuple) as the prefix argument | |
| # https://github.com/facebookexperimental/starlark-rust/issues/23 | |
| # 'a'.endswith(['a']) # # # (Type of parameter.*doesn't match|got list|parameters mismatch) | |
| # --- | |
| # startswith | |
| assert_eq('Apricot'.startswith('Apr'), True) | |
| assert_eq('Apricot'.startswith('A'), True) | |
| assert_eq('Apricot'.startswith(''), True) | |
| assert_eq('Apricot'.startswith('z'), False) | |
| assert_eq(''.startswith(''), True) | |
| assert_eq(''.startswith('a'), False) | |
| assert_eq('Apricot'.startswith(('Apr', 'rpA')), True) | |
| assert_eq('Apricot'.startswith(('rpA', 'Apr')), True) | |
| assert_eq('a'.startswith(('', '')), True) | |
| assert_eq('a'.startswith(('', 'a')), True) | |
| assert_eq('a'.startswith(('a', 'a')), True) | |
| assert_eq(''.startswith(('a', '')), True) | |
| assert_eq(''.startswith(('', '')), True) | |
| assert_eq(''.startswith(('a', 'a')), False) | |
| assert_eq('a'.startswith(('a')), True) | |
| assert_eq('a'.startswith(('a',)), True) | |
| assert_eq('a'.startswith(('b',)), False) | |
| assert_eq('a'.startswith(()), False) | |
| assert_eq(''.startswith(()), False) | |
| # _inconsistency_: rust startswith() accepts a list (not just a tuple) as the prefix argument | |
| # https://github.com/facebookexperimental/starlark-rust/issues/23 | |
| # 'a'.startswith(['a']) # # # (Type of parameter.*doesn't match|got list|expected string) | |
| # --- | |
| # substring | |
| assert_eq('012345678'[0:-1], "01234567") | |
| assert_eq('012345678'[2:4], "23") | |
| assert_eq('012345678'[-5:-3], "45") | |
| assert_eq('012345678'[2:2], "") | |
| assert_eq('012345678'[2:], "2345678") | |
| assert_eq('012345678'[:3], "012") | |
| assert_eq('012345678'[-1:], "8") | |
| assert_eq('012345678'[:], "012345678") | |
| assert_eq('012345678'[-1:2], "") | |
| assert_eq('012345678'[4:2], "") | |
| # count | |
| assert_eq('abc'.count('a'), 1) | |
| assert_eq('abc'.count('b'), 1) | |
| assert_eq('abc'.count('c'), 1) | |
| assert_eq('abbc'.count('b'), 2) | |
| assert_eq('aba'.count('a'), 2) | |
| assert_eq('aaa'.count('aa'), 1) | |
| assert_eq('aaaa'.count('aa'), 2) | |
| assert_eq('abc'.count('a', 0), 1) | |
| assert_eq('abc'.count('a', 1), 0) | |
| assert_eq('abc'.count('c', 0, 3), 1) | |
| assert_eq('abc'.count('c', 0, 2), 0) | |
| assert_eq('abc'.count('a', -1), 0) | |
| assert_eq('abc'.count('c', -1), 1) | |
| assert_eq('abc'.count('c', 0, 5), 1) | |
| assert_eq('abc'.count('c', 0, -1), 0) | |
| assert_eq('abc'.count('a', 0, -1), 1) | |
| # isalpha | |
| assert_eq(''.isalpha(), False) | |
| assert_eq('abz'.isalpha(), True) | |
| assert_eq('a1'.isalpha(), False) | |
| assert_eq('a '.isalpha(), False) | |
| assert_eq('A'.isalpha(), True) | |
| assert_eq('AbZ'.isalpha(), True) | |
| assert_eq('lawl'.partition('a'), ('l', 'a', 'wl')) | |
| assert_eq('lawl'.rpartition('a'), ('l', 'a', 'wl')) | |
| assert_eq('google'.partition('o'), ('g', 'o', 'ogle')) | |
| assert_eq('google'.rpartition('o'), ('go', 'o', 'gle')) | |
| assert_eq('xxx'.partition('x'), ('', 'x', 'xx')) | |
| assert_eq('xxx'.rpartition('x'), ('xx', 'x', '')) | |
| assert_eq(''.partition('a'), ('', '', '')) | |
| assert_eq(''.rpartition('a'), ('', '', '')) | |
| # _inconsistency_: go has no default value for separator in partion() | |
| # default separator | |
| # assert_eq('hi this is a test'.partition(), ('hi', ' ', 'this is a test')) | |
| # assert_eq('hi this is a test'.rpartition(), ('hi this is a', ' ', 'test')) | |
| # assert_eq('google'.partition(), ('google', '', '')) | |
| # assert_eq('google'.rpartition(), ('', '', 'google')) | |
| # no match | |
| assert_eq('google'.partition('x'), ('google', '', '')) | |
| assert_eq('google'.rpartition('x'), ('', '', 'google')) | |
| # at word boundaries | |
| assert_eq('goog'.partition('g'), ('', 'g', 'oog')) | |
| assert_eq('goog'.rpartition('g'), ('goo', 'g', '')) | |
| assert_eq('plex'.partition('p'), ('', 'p', 'lex')) | |
| assert_eq('plex'.rpartition('p'), ('', 'p', 'lex')) | |
| assert_eq('plex'.partition('x'), ('ple', 'x', '')) | |
| assert_eq('plex'.rpartition('x'), ('ple', 'x', '')) | |
| assert_eq('google'.partition('oog'), ('g', 'oog', 'le')) | |
| assert_eq('google'.rpartition('oog'), ('g', 'oog', 'le')) | |
| assert_eq('lolgooglolgooglolgooglol'.partition('goog'), ('lol', 'goog', 'lolgooglolgooglol')) | |
| assert_eq('lolgooglolgooglolgooglol'.rpartition('goog'), ('lolgooglolgooglol', 'goog', 'lol')) | |
| # full string | |
| assert_eq('google'.partition('google'), ('', 'google', '')) | |
| assert_eq('google'.rpartition('google'), ('', 'google', '')) | |
| # indexing | |
| assert_eq('somestring'[0], "s") | |
| assert_eq('somestring'[1], "o") | |
| assert_eq('somestring'[4], "s") | |
| assert_eq('somestring'[9], "g") | |
| assert_eq('somestring'[-1], "g") | |
| assert_eq('somestring'[-2], "n") | |
| assert_eq('somestring'[-10], "s") | |
| # slicing | |
| assert_eq('0123'[0:-1], "012") | |
| assert_eq('012345'[2:4], "23") | |
| assert_eq('012345'[-2:-1], "4") | |
| assert_eq(''[1:2], "") | |
| assert_eq('012'[1:0], "") | |
| assert_eq('0123'[-10:10], "0123") | |
| assert_eq('01234'[::1], "01234") | |
| assert_eq('01234'[1::1], "1234") | |
| assert_eq('01234'[:2:1], "01") | |
| assert_eq('01234'[1:3:1], "12") | |
| assert_eq('01234'[-4:-2:1], "12") | |
| assert_eq('01234'[-10:10:1], "01234") | |
| assert_eq('01234'[::42], "0") | |
| assert_eq(''[::1], "") | |
| assert_eq(''[::-1], "") | |
| assert_eq('0123456'[::3], "036") | |
| assert_eq('01234567'[1:7:3], "14") | |
| assert_eq('01234'[::-1], "43210") | |
| assert_eq('01234'[4::-1], "43210") | |
| assert_eq('01234'[:0:-1], "4321") | |
| assert_eq('01234'[3:1:-1], "32") | |
| assert_eq('01234'[::-2], "420") | |
| assert_eq('01234'[::-10], "4") | |
| assert_eq('123'[3:1:1], "") | |
| assert_eq('123'[1:3:-1], "") | |
| # split | |
| assert_eq('h i'.split(' '), ['h', 'i']) | |
| assert_eq('h i p'.split(' '), ['h', 'i', 'p']) | |
| assert_eq('a,e,i,o,u'.split(',', 2), ['a', 'e', 'i,o,u']) | |
| assert_eq(' 1 2 3 '.split(' '), ['', '', '1', '', '2', '', '3', '', '']) | |
| # rsplit | |
| assert_eq('abcdabef'.rsplit('ab'), ['', 'cd', 'ef']) | |
| assert_eq('google_or_gogol'.rsplit('go'), ['', 'ogle_or_', '', 'l']) | |
| # rsplit regex | |
| assert_eq('foo/bar.lisp'.rsplit('.'), ['foo/bar', 'lisp']) | |
| assert_eq('foo/bar.?lisp'.rsplit('.?'), ['foo/bar', 'lisp']) | |
| assert_eq('fwe$foo'.rsplit('$'), ['fwe', 'foo']) | |
| assert_eq('windows'.rsplit('*'), ['windows']) | |
| # rsplit no match | |
| assert_eq(''.rsplit('o'), ['']) | |
| assert_eq('google'.rsplit('x'), ['google']) | |
| # rsplit separator | |
| assert_eq('xxxxxx'.rsplit('x'), ['', '', '', '', '', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 1), ['xxxxx', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 2), ['xxxx', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 3), ['xxx', '', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 4), ['xx', '', '', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 5), ['x', '', '', '', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 6), ['', '', '', '', '', '', '']) | |
| assert_eq('xxxxxx'.rsplit('x', 7), ['', '', '', '', '', '', '']) | |
| # split max split | |
| assert_eq('google'.rsplit('o'), ['g', '', 'gle']) | |
| assert_eq('google'.rsplit('o'), ['g', '', 'gle']) | |
| assert_eq('google'.rsplit('o', 1), ['go', 'gle']) | |
| assert_eq('google'.rsplit('o', 2), ['g', '', 'gle']) | |
| assert_eq('google'.rsplit('o', 3), ['g', '', 'gle']) | |
| assert_eq('ogooglo'.rsplit('o'), ['', 'g', '', 'gl', '']) | |
| assert_eq('ogooglo'.rsplit('o', 1), ['ogoogl', '']) | |
| assert_eq('ogooglo'.rsplit('o', 2), ['ogo', 'gl', '']) | |
| assert_eq('ogooglo'.rsplit('o', 3), ['og', '', 'gl', '']) | |
| assert_eq('ogooglo'.rsplit('o', 4), ['', 'g', '', 'gl', '']) | |
| assert_eq('ogooglo'.rsplit('o', 5), ['', 'g', '', 'gl', '']) | |
| assert_eq('google'.rsplit('google'), ['', '']) | |
| assert_eq('google'.rsplit('google', 1), ['', '']) | |
| assert_eq('google'.rsplit('google', 2), ['', '']) | |
| # Empty line | |
| assert_eq(''.splitlines(), []) | |
| assert_eq('\n'.splitlines(), ['']) | |
| # Starts with line break | |
| assert_eq('\ntest'.splitlines(), ['', 'test']) | |
| # Ends with line break | |
| assert_eq('test\n'.splitlines(), ['test']) | |
| # Different line breaks | |
| assert_eq('this\nis\na\ntest'.splitlines(), ['this', 'is', 'a', 'test']) | |
| # _inconsistency_: go splits on \n only | |
| # Only line breaks | |
| # assert_eq('\r\r\r'.splitlines(), ['', '', '']) | |
| # assert_eq('\n\r\n\r'.splitlines(), ['', '', '']) | |
| # assert_eq('\r\n\r\n\r\n'.splitlines(), ['', '', '']) | |
| assert_eq('\n\n\n'.splitlines(), ['', '', '']) | |
| # Escaped sequences | |
| assert_eq('\n\\n\\\n'.splitlines(), ['', '\\n\\']) | |
| # KeepEnds | |
| assert_eq(''.splitlines(True), []) | |
| assert_eq('\n'.splitlines(True), ['\n']) | |
| assert_eq('this\nis\na\ntest'.splitlines(True), ['this\n', 'is\n', 'a\n', 'test']) | |
| assert_eq('\ntest'.splitlines(True), ['\n', 'test']) | |
| assert_eq('test\n'.splitlines(True), ['test\n']) | |
| assert_eq('\n\\n\\\n'.splitlines(True), ['\n', '\\n\\\n']) | |
| # _inconsistency_: go splits on \n only | |
| # assert_eq('this\nis\r\na\rtest'.splitlines(True), ['this\n', 'is\r\n', 'a\r', 'test']) | |
| # isalnum | |
| assert_eq(''.isalnum(), False) | |
| assert_eq('a0 33'.isalnum(), False) | |
| assert_eq('1'.isalnum(), True) | |
| assert_eq('a033'.isalnum(), True) | |
| # isdigit | |
| assert_eq(''.isdigit(), False) | |
| assert_eq(' '.isdigit(), False) | |
| assert_eq('a'.isdigit(), False) | |
| assert_eq('0234325.33'.isdigit(), False) | |
| assert_eq('1'.isdigit(), True) | |
| assert_eq('033'.isdigit(), True) | |
| # isspace | |
| assert_eq(''.isspace(), False) | |
| assert_eq('a'.isspace(), False) | |
| assert_eq('1'.isspace(), False) | |
| assert_eq('\ta\n'.isspace(), False) | |
| assert_eq(' '.isspace(), True) | |
| assert_eq('\t\n'.isspace(), True) | |
| # islower | |
| assert_eq(''.islower(), False) | |
| assert_eq(' '.islower(), False) | |
| assert_eq('1'.islower(), False) | |
| assert_eq('Almost'.islower(), False) | |
| assert_eq('abc'.islower(), True) | |
| assert_eq(' \nabc'.islower(), True) | |
| assert_eq('abc def\n'.islower(), True) | |
| assert_eq('\ta\n'.islower(), True) | |
| # isupper | |
| assert_eq(''.isupper(), False) | |
| assert_eq(' '.isupper(), False) | |
| assert_eq('1'.isupper(), False) | |
| assert_eq('aLMOST'.isupper(), False) | |
| assert_eq('ABC'.isupper(), True) | |
| assert_eq(' \nABC'.isupper(), True) | |
| assert_eq('ABC DEF\n'.isupper(), True) | |
| assert_eq('\tA\n'.isupper(), True) | |
| # istitle | |
| assert_eq(''.istitle(), False) | |
| assert_eq(' '.istitle(), False) | |
| assert_eq('134'.istitle(), False) | |
| assert_eq('almost Correct'.istitle(), False) | |
| assert_eq('1nope Nope Nope'.istitle(), False) | |
| assert_eq('NO Way'.istitle(), False) | |
| assert_eq('T'.istitle(), True) | |
| assert_eq('Correct'.istitle(), True) | |
| assert_eq('Very Correct! Yes\nIndeed1X'.istitle(), True) | |
| assert_eq('1234Ab Ab'.istitle(), True) | |
| assert_eq('\tA\n'.istitle(), True) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| load("@rules_graalvm//graalvm:defs.bzl", "native_image") | |
| native_image( | |
| name = "main-native", | |
| deps = ["@io_bazel//src/main/java/net/starlark/java/cmd:starlark"], | |
| main_class = "net.starlark.java.cmd.Main", | |
| native_image_tool = "@graalvm//:native-image", | |
| reflection_configuration = ":reflect-config.json", | |
| ) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| [ | |
| { | |
| "name":"[Ljava.lang.Object;" | |
| }, | |
| { | |
| "name":"com.google.common.flogger.backend.system.DefaultPlatform", | |
| "methods":[{"name":"<init>","parameterTypes":[] }] | |
| }, | |
| { | |
| "name":"java.lang.Comparable", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.lang.Iterable", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.lang.Object", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.AbstractCollection", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.AbstractList", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.Collection", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.List", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.Map", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.RandomAccess", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"java.util.concurrent.atomic.AtomicReference", | |
| "fields":[{"name":"value"}] | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.Dict", | |
| "queryAllDeclaredMethods":true, | |
| "queryAllPublicMethods":true, | |
| "methods":[{"name":"get2","parameterTypes":["java.lang.Object","java.lang.Object","net.starlark.java.eval.StarlarkThread"] }, {"name":"items","parameterTypes":["net.starlark.java.eval.StarlarkThread"] }, {"name":"keys","parameterTypes":["net.starlark.java.eval.StarlarkThread"] }, {"name":"pop","parameterTypes":["java.lang.Object","java.lang.Object","net.starlark.java.eval.StarlarkThread"] }, {"name":"popitem","parameterTypes":[] }, {"name":"setdefault","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"update","parameterTypes":["java.lang.Object","net.starlark.java.eval.Dict","net.starlark.java.eval.StarlarkThread"] }, {"name":"values0","parameterTypes":["net.starlark.java.eval.StarlarkThread"] }] | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.MethodLibrary", | |
| "queryAllDeclaredMethods":true, | |
| "queryAllPublicMethods":true, | |
| "methods":[{"name":"all","parameterTypes":["java.lang.Object"] }, {"name":"any","parameterTypes":["java.lang.Object"] }, {"name":"dict","parameterTypes":["java.lang.Object","net.starlark.java.eval.Dict","net.starlark.java.eval.StarlarkThread"] }, {"name":"intForStarlark","parameterTypes":["java.lang.Object","java.lang.Object"] }, {"name":"list","parameterTypes":["net.starlark.java.eval.StarlarkIterable","net.starlark.java.eval.StarlarkThread"] }, {"name":"max","parameterTypes":["net.starlark.java.eval.Sequence"] }, {"name":"min","parameterTypes":["net.starlark.java.eval.Sequence"] }, {"name":"print","parameterTypes":["java.lang.String","net.starlark.java.eval.Sequence","net.starlark.java.eval.StarlarkThread"] }, {"name":"range","parameterTypes":["net.starlark.java.eval.StarlarkInt","java.lang.Object","net.starlark.java.eval.StarlarkInt","net.starlark.java.eval.StarlarkThread"] }, {"name":"reversed","parameterTypes":["net.starlark.java.eval.StarlarkIterable","net.starlark.java.eval.StarlarkThread"] }] | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.Mutability$Freezable", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.Sequence", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.StarlarkIndexable", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.StarlarkIterable", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.StarlarkList", | |
| "queryAllDeclaredMethods":true, | |
| "queryAllPublicMethods":true, | |
| "methods":[{"name":"append","parameterTypes":["java.lang.Object"] }, {"name":"extend","parameterTypes":["java.lang.Object"] }, {"name":"insert","parameterTypes":["net.starlark.java.eval.StarlarkInt","java.lang.Object"] }, {"name":"pop","parameterTypes":["java.lang.Object"] }, {"name":"removeElement","parameterTypes":["java.lang.Object"] }] | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.StarlarkValue", | |
| "queryAllDeclaredMethods":true | |
| }, | |
| { | |
| "name":"net.starlark.java.eval.StringModule", | |
| "queryAllDeclaredMethods":true, | |
| "queryAllPublicMethods":true, | |
| "methods":[{"name":"capitalize","parameterTypes":["java.lang.String"] }, {"name":"count","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","java.lang.Object"] }, {"name":"endsWith","parameterTypes":["java.lang.String","java.lang.Object","java.lang.Object","java.lang.Object"] }, {"name":"find","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","java.lang.Object"] }, {"name":"format","parameterTypes":["java.lang.String","net.starlark.java.eval.Tuple","net.starlark.java.eval.Dict","net.starlark.java.eval.StarlarkThread"] }, {"name":"index","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","java.lang.Object"] }, {"name":"isAlnum","parameterTypes":["java.lang.String"] }, {"name":"isAlpha","parameterTypes":["java.lang.String"] }, {"name":"isDigit","parameterTypes":["java.lang.String"] }, {"name":"isLower","parameterTypes":["java.lang.String"] }, {"name":"isSpace","parameterTypes":["java.lang.String"] }, {"name":"isTitle","parameterTypes":["java.lang.String"] }, {"name":"isUpper","parameterTypes":["java.lang.String"] }, {"name":"join","parameterTypes":["java.lang.String","java.lang.Object","net.starlark.java.eval.StarlarkThread"] }, {"name":"lower","parameterTypes":["java.lang.String"] }, {"name":"partition","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"replace","parameterTypes":["java.lang.String","java.lang.String","java.lang.String","net.starlark.java.eval.StarlarkInt","net.starlark.java.eval.StarlarkThread"] }, {"name":"rfind","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","java.lang.Object"] }, {"name":"rindex","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","java.lang.Object"] }, {"name":"rpartition","parameterTypes":["java.lang.String","java.lang.String"] }, {"name":"rsplit","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","net.starlark.java.eval.StarlarkThread"] }, {"name":"split","parameterTypes":["java.lang.String","java.lang.String","java.lang.Object","net.starlark.java.eval.StarlarkThread"] }, {"name":"splitLines","parameterTypes":["java.lang.String","boolean","net.starlark.java.eval.StarlarkThread"] }, {"name":"startsWith","parameterTypes":["java.lang.String","java.lang.Object","java.lang.Object","java.lang.Object"] }, {"name":"title","parameterTypes":["java.lang.String"] }, {"name":"upper","parameterTypes":["java.lang.String"] }] | |
| }, | |
| { | |
| "name":"sun.misc.SharedSecrets" | |
| } | |
| ] |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| # run with | |
| # bazel run @io_bazel//src/main/java/net/starlark/java/cmd:starlark --noenable_bzlmod --java_runtime_version=remotejdk_11 | |
| # | |
| # to build native image run: | |
| # ./graalvm-jdk/bin/native-image --no-fallback $((bazel run @io_bazel//src/main/java/net/starlark/java/cmd:starlark --noenable_bzlmod --java_runtime_version=remotejdk_11 --run_under='bash -x' & pkill starlark) |& grep '^+ exec' | cut -d" " -f4- | sed -e 's|-XX:+IgnoreUnrecognizedVMOptions||g' -e "s|\.\./|$(bazel info execution_root --noenable_bzlmod 2>/dev/null)/bazel-out/k8-fastbuild/bin/external/io_bazel/src/main/java/net/starlark/java/cmd/starlark.runfiles/|g") | |
| # starlark_jar="$(bazel run @io_bazel//src/main/java/net/starlark/java/cmd:starlark_deploy.jar --noenable_bzlmod --java_runtime_version=remotejdk_11 --run_under=ls)" | |
| # mkdir output_trace_dir | |
| # ./graalvm-jdk/bin/java -agentlib:native-image-agent=config-output-dir=output_trace_dir/ -jar "${starlark_jar}" all_tests.star | |
| # ./graalvm-jdk/bin/native-image -H:ReflectionConfigurationFiles=output_trace_dir/reflect-config.json -jar "${starlark_jar}" | |
| # ./starlark_deploy all_tests.star | |
| # rm -fr output_trace_dir | |
| #./packelf.sh starlark_deploy | |
| # or bazel build :main-native | |
| load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") | |
| http_archive( | |
| name = "io_bazel", | |
| url = "https://github.com/bazelbuild/bazel/archive/4853dfd02ac7440a04caada830b7b61b6081bdfe.tar.gz", | |
| strip_prefix = "bazel-4853dfd02ac7440a04caada830b7b61b6081bdfe", | |
| integrity = "sha256-KCkUTQLEBoy0pJ0diW6EcuC8V71S3gebLxXD2OXX+Sw=", | |
| patches = ["//:0001-expose-starlark-as-java_library-target.patch"], | |
| patch_args = ["-p1"], | |
| ) | |
| http_archive( | |
| name = "rules_pkg", | |
| sha256 = "5bdc04987af79bd27bc5b00fe30f59a858f77ffa0bd2d8143d5b31ad8b1bd71c", | |
| urls = [ | |
| "https://mirror.bazel.build/github.com/bazelbuild/rules_pkg/rules_pkg-0.2.0.tar.gz", | |
| "https://github.com/bazelbuild/rules_pkg/releases/download/0.2.0/rules_pkg-0.2.0.tar.gz", | |
| ], | |
| ) | |
| load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies") | |
| rules_pkg_dependencies() | |
| http_archive( | |
| name = "rules_jvm_external", | |
| sha256 = "b17d7388feb9bfa7f2fa09031b32707df529f26c91ab9e5d909eb1676badd9a6", | |
| strip_prefix = "rules_jvm_external-4.5", | |
| url = "https://github.com/bazelbuild/rules_jvm_external/archive/4.5.zip", | |
| ) | |
| load("@rules_jvm_external//:repositories.bzl", "rules_jvm_external_deps") | |
| rules_jvm_external_deps() | |
| load("@rules_jvm_external//:setup.bzl", "rules_jvm_external_setup") | |
| rules_jvm_external_setup() | |
| load("@rules_jvm_external//:defs.bzl", "maven_install") | |
| # @io_bazel//src/main/java/net/starlark/java/cmd:starlark dependencies | |
| maven_install( | |
| artifacts = [ | |
| "com.google.guava:guava:31.1-jre", | |
| "com.google.errorprone:error_prone_type_annotations:2.16", | |
| "com.google.code.findbugs:jsr305:3.0.2", | |
| "com.github.stephenc.jcip:jcip-annotations:1.0-1", | |
| ], | |
| repositories = [ | |
| "https://dl.google.com/android/maven2", | |
| "https://repo1.maven.org/maven2", | |
| ], | |
| ) | |
| http_archive( | |
| name = "rules_graalvm", | |
| sha256 = "e4fa275b062dcd03b1ecb02bb25f01ead512023006a874a5e0c2cb78ba6d8e73", | |
| strip_prefix = "rules_graalvm-0.11.1", | |
| urls = [ | |
| "https://github.com/sgammon/rules_graalvm/releases/download/v0.11.1/rules_graalvm-0.11.1.zip", | |
| ], | |
| ) | |
| load("@rules_graalvm//graalvm:repositories.bzl", "graalvm_repository") | |
| graalvm_repository( | |
| name = "graalvm", | |
| distribution = "ce", # `oracle`, `ce`, or `community` | |
| java_version = "21", # `17`, `20`, or `21`, as supported by the version provided | |
| version = "21.0.2", # earlier version format like `22.x` also supported | |
| ) | |
| load("@rules_graalvm//graalvm:workspace.bzl", "register_graalvm_toolchains", "rules_graalvm_repositories") | |
| rules_graalvm_repositories() | |
| register_graalvm_toolchains() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Jak dorosnę chciał bym być taki jak ty!