---
source: src/main.rs
expression: compiled
input_file: test-data/lua5.1-tests/nextvar.lua
---
print('testing tables, next, and for');
local a = {}
for i = 1, 100 {
a[(i .. "+")] = true
}
for i = 1, 100 {
a[(i .. "+")] = nil
}
for i = 1, 100 {
a[(i)] = true
assert(#a == i);
}
if T {
local l2 = math.log(2)
local fn log2(x) {
return math.log(x) / l2
}
local fn mp2(n) {
local mp = 2 ^ math.ceil(log2(n))
assert(n == 0 || (mp / 2 < n && n <= mp));
return mp
}
local fn fb(n) {
local r, nn = T.int2fb(n)
assert(r < 256);
return nn
}
local a = 1
local lim = 2 ^ 30
while a < lim {
local n = fb(a)
assert(a <= n && n <= a * 1.125);
a = math.ceil(a * 1.3)
}
local fn check(t, na, nh) {
local a, h = T.querytab(t)
if a != na || h != nh {
print(na, nh, a, h);
assert(nil);
}
}
local lim = 40
local s = 'return {'
for i = 1, lim {
s = s .. i .. ','
local s = s
for k = 0, lim {
local t = loadstring(s .. '}')()
assert(#t == i);
check(t, fb(i), mp2(k));
s = string.format('%sa%d=%d,', s, k, k)
}
}
local a = {}
for i = 1, lim {
a[(i)] = i
}
for k = 0, lim {
local a = {
unpack(a, 1, k)
}
assert(#a == k);
check(a, k, 0);
a = {
1,
2,
3,
unpack(a, 1, k)
}
check(a, k + 3, 0);
assert(#a == k + 3);
}
print('+');
local lim = 130
local a = {}
a[(2)] = 1
check(a, 0, 1);
a = {}
a[(0)] = 1
check(a, 0, 1);
a[(2)] = 1
check(a, 0, 2);
a = {}
a[(0)] = 1
a[(1)] = 1
check(a, 1, 1);
a = {}
for i = 1, lim {
a[(i)] = 1
assert(#a == i);
check(a, mp2(i), 0);
}
a = {}
for i = 1, lim {
a[('a' .. i)] = 1
assert(#a == 0);
check(a, 0, mp2(i));
}
a = {}
for i = 1, 16 {
a[(i)] = i
}
check(a, 16, 0);
for i = 1, 11 {
a[(i)] = nil
}
for i = 30, 40 {
a[(i)] = nil
}
check(a, 0, 8);
a[(10)] = 1
for i = 30, 40 {
a[(i)] = nil
}
check(a, 0, 8);
for i = 1, 14 {
a[(i)] = nil
}
for i = 30, 50 {
a[(i)] = nil
}
check(a, 0, 4);
for i = 1, lim {
local a = {}
for i = i, 1, -1 {
a[(i)] = i
}
check(a, mp2(i), 0);
}
lim = 35
global fn foo(n, ...) {
local arg = {
...
}
check(arg, n, 0);
assert(select('#', ...) == n);
arg[(n + 1)] = true
check(arg, mp2(n + 1), 0);
arg.x = true
check(arg, mp2(n + 1), 1);
}
local a = {}
for i = 1, lim {
a[(i)] = true
foo(i, unpack(a));
}
}
assert(#{} == 0);
assert(#{
nil
} == 0);
assert(#{
nil,
nil
} == 0);
assert(#{
nil,
nil,
nil
} == 0);
assert(#{
nil,
nil,
nil,
nil
} == 0);
print('+');
local nofind = {}
a, b, c = 1, 2, 3
a, b, c = nil
local fn find(name) {
local n, v
while 1 {
n, v = next(_G, n)
if !n {
return nofind
}
assert(v != nil);
if n == name {
return v
}
}
}
local fn find1(name) {
for n, v with pairs(_G) {
if n == name {
return v
}
}
return nil
}
{
for i = 1, 10000 {
_G[(i)] = i
}
}
a = {
x = 90,
y = 8,
z = 23
}
assert(table.foreach(a, fn (i, v) {
if i == 'x' {
return v
}
}) == 90);
assert(table.foreach(a, fn (i, v) {
if i == 'a' {
return v
}
}) == nil);
table.foreach({}, error);
table.foreachi({
x = 10,
y = 20
}, error);
local a = {
n = 1
}
table.foreachi({
n = 3
}, fn (i, v) {
assert(a.n == i && !v);
a.n = a.n + 1
});
a = {
10,
20,
30,
nil,
50
}
table.foreachi(a, fn (i, v) {
assert(a[(i)] == v);
});
assert(table.foreachi({
'a',
'b',
'c'
}, fn (i, v) {
if i == 2 {
return v
}
}) == 'b');
assert(print == find("print") && print == find1("print"));
assert(_G[("print")] == find("print"));
assert(assert == find1("assert"));
assert(nofind == find("return"));
assert(!find1("return"));
_G[("ret" .. "urn")] = nil
assert(nofind == find("return"));
_G[("xxx")] = 1
assert(xxx == find("xxx"));
print('+');
a = {}
for i = 0, 10000 {
if math.mod(i, 10) != 0 {
a[('x' .. i)] = i
}
}
n = {
n = 0
}
for i, v with pairs(a) {
n.n = n.n + 1
assert(i && v && a[(i)] == v);
}
assert(n.n == 9000);
a = nil
for i = 1, 10000 {
_G[(i)] = nil
}
{
local a = {}
local preserve = {
io = 1,
string = 1,
debug = 1,
os = 1,
coroutine = 1,
table = 1,
math = 1
}
for n, v with pairs(_G) {
a[(n)] = v
}
for n, v with pairs(a) {
if !preserve[(n)] && type(v) != "function" && !string.find(n, "^[%u_]") {
_G[(n)] = nil
}
collectgarbage();
}
}
local fn foo() {
local getfenv, setfenv, assert, next = getfenv, setfenv, assert, next
local n = {
gl1 = 3
}
setfenv(foo, n);
assert(getfenv(foo) == getfenv(1));
assert(getfenv(foo) == n);
assert(print == nil && gl1 == 3);
gl1 = nil
gl = 1
assert(n.gl == 1 && next(n, 'gl') == nil);
}
foo();
print('+');
local fn checknext(a) {
local b = {}
table.foreach(a, fn (k, v) {
b[(k)] = v
});
for k, v with pairs(b) {
assert(a[(k)] == v);
}
for k, v with pairs(a) {
assert(b[(k)] == v);
}
b = {}
{
local k, v = next(a)
while k {
b[(k)] = v
k, v = next(a, k)
}
}
for k, v with pairs(b) {
assert(a[(k)] == v);
}
for k, v with pairs(a) {
assert(b[(k)] == v);
}
}
checknext({
1,
x = 1,
y = 2,
z = 3
});
checknext({
1,
2,
x = 1,
y = 2,
z = 3
});
checknext({
1,
2,
3,
x = 1,
y = 2,
z = 3
});
checknext({
1,
2,
3,
4,
x = 1,
y = 2,
z = 3
});
checknext({
1,
2,
3,
4,
5,
x = 1,
y = 2,
z = 3
});
assert(table.getn({}) == 0);
assert(table.getn({
-1 = 2
}) == 0);
assert(table.getn({
1,
2,
3,
nil,
nil
}) == 3);
for i = 0, 40 {
local a = {}
for j = 1, i {
a[(j)] = j
}
assert(table.getn(a) == i);
}
assert(table.maxn({}) == 0);
assert(table.maxn({
"1000" = true
}) == 0);
assert(table.maxn({
"1000" = true,
24.5 = 3
}) == 24.5);
assert(table.maxn({
1000 = true
}) == 1000);
assert(table.maxn({
10 = true,
100 * math.pi = print
}) == 100 * math.pi);
a = {}
for i = 0, 50 {
a[(math.pow(2, i))] = true
}
assert(a[(table.getn(a))]);
print("+");
local t = {
{
1
} = 1,
{
2
} = 2,
string.rep("x ", 4) = 3,
100.3 = 4,
4 = 5
}
local n = 0
for k, v with pairs(t) {
n = n + 1
assert(t[(k)] == v);
t[(k)] = nil
collectgarbage();
assert(t[(k)] == nil);
}
assert(n == 5);
local fn test(a) {
table.insert(a, 10);
table.insert(a, 2, 20);
table.insert(a, 1, -1);
table.insert(a, 40);
table.insert(a, table.getn(a) + 1, 50);
table.insert(a, 2, -2);
assert(table.remove(a, 1) == -1);
assert(table.remove(a, 1) == -2);
assert(table.remove(a, 1) == 10);
assert(table.remove(a, 1) == 20);
assert(table.remove(a, 1) == 40);
assert(table.remove(a, 1) == 50);
assert(table.remove(a, 1) == nil);
}
a = {
n = 0,
-7 = "ban"
}
test(a);
assert(a.n == 0 && a[(-7)] == "ban");
a = {
-7 = "ban"
}
test(a);
assert(a.n == nil && table.getn(a) == 0 && a[(-7)] == "ban");
table.insert(a, 1, 10);
table.insert(a, 1, 20);
table.insert(a, 1, -1);
assert(table.remove(a) == 10);
assert(table.remove(a) == 20);
assert(table.remove(a) == -1);
a = {
'c',
'd'
}
table.insert(a, 3, 'a');
table.insert(a, 'b');
assert(table.remove(a, 1) == 'c');
assert(table.remove(a, 1) == 'd');
assert(table.remove(a, 1) == 'a');
assert(table.remove(a, 1) == 'b');
assert(table.getn(a) == 0 && a.n == nil);
print("+");
a = {}
for i = 1, 1000 {
a[(i)] = i
a[(i - 1)] = nil
}
assert(next(a, nil) == 1000 && next(a, 1000) == nil);
assert(next({}) == nil);
assert(next({}, nil) == nil);
for a, b with pairs({}) {
error("not here");
}
for i = 1, 0 {
error('not here');
}
for i = 0, 1, -1 {
error('not here');
}
a = nil
for i = 1, 1 {
assert(!a);
a = 1
}
assert(a);
a = nil
for i = 1, 1, -1 {
assert(!a);
a = 1
}
assert(a);
a = 0
for i = 0, 1, 0.1 {
a = a + 1
}
assert(a == 11);
a = 0
for i = 0, 0.999999999, 0.1 {
a = a + 1
}
assert(a == 10);
a = 0
for i = 1, 1, 1 {
a = a + 1
}
assert(a == 1);
a = 0
for i = 1e10, 1e10, -1 {
a = a + 1
}
assert(a == 1);
a = 0
for i = 1, 0.99999, 1 {
a = a + 1
}
assert(a == 0);
a = 0
for i = 99999, 1e5, -1 {
a = a + 1
}
assert(a == 0);
a = 0
for i = 1, 0.99999, -1 {
a = a + 1
}
assert(a == 1);
a = 0
for i = "10", "1", "-2" {
a = a + 1
}
assert(a == 5);
collectgarbage();
local fn f(n, p) {
local t = {}
for i = 1, p {
t[(i)] = i * 10
}
return fn (_, n) {
if n > 0 {
n = n - 1
return n, unpack(t)
}
}, nil, n
}
local x = 0
for n, a, b, c, d with f(5, 3) {
x = x + 1
assert(a == 10 && b == 20 && c == 30 && d == nil);
}
assert(x == 5);
print("OK");