---
source: src/main.rs
expression: compiled
input_file: test-data/lua5.1-tests/attrib.lua
---
{
print("testing require");
assert(require("string") == string);
assert(require("math") == math);
assert(require("table") == table);
assert(require("io") == io);
assert(require("os") == os);
assert(require("debug") == debug);
assert(require("coroutine") == coroutine);
assert(type(package.path) == "string");
assert(type(package.cpath) == "string");
assert(type(package.loaded) == "table");
assert(type(package.preload) == "table");
local DIR = "libs/"
local fn createfiles(files, preextras, posextras) {
for n, c with pairs(files) {
io.output(DIR .. n);
io.write(string.format(preextras, n));
io.write(c);
io.write(string.format(posextras, n));
io.close(io.output());
}
}
global fn removefiles(files) {
for n with pairs(files) {
os.remove(DIR .. n);
}
}
local files = {
"A.lua" = "",
"B.lua" = "assert(...=='B');require 'A'",
"A.lc" = "",
"A" = "",
"L" = "",
"XXxX" = "",
"C.lua" = "package.loaded[...] = 25; require'C'"
}
AA = nil
local extras = `
NAME = '%s'
REQUIRED = ...
return AA`
createfiles(files, "", extras);
local oldpath = package.path
package.path = string.gsub("D/?.lua;D/?.lc;D/?;D/??x?;D/L", "D/", DIR)
local try = fn (p, n, r) {
NAME = nil
local rr = require(p)
assert(NAME == n);
assert(REQUIRED == p);
assert(rr == r);
}
assert(require("C") == 25);
assert(require("C") == 25);
AA = nil
try('B', 'B.lua', true);
assert(package.loaded.B);
assert(require("B") == true);
assert(package.loaded.A);
package.loaded.A = nil
try('B', nil, true);
try('A', 'A.lua', true);
package.loaded.A = nil
os.remove(DIR .. 'A.lua');
AA = {}
try('A', 'A.lc', AA);
assert(require("A") == AA);
AA = false
try('K', 'L', false);
try('K', 'L', false);
assert(rawget(_G, "_REQUIREDNAME") == nil);
AA = "x"
try("X", "XXxX", AA);
removefiles(files);
package.path = string.gsub("D/?.lua;D/?/init.lua", "D/", DIR)
files = {
"P1/init.lua" = "AA = 10",
"P1/xuxu.lua" = "AA = 20"
}
createfiles(files, "module(..., package.seeall)\n", "");
AA = 0
local m = assert(require("P1"))
assert(m == P1 && m._NAME == "P1" && AA == 0 && m.AA == 10);
assert(require("P1") == P1 && P1 == m);
assert(require("P1") == P1);
assert(P1._PACKAGE == "");
local m = assert(require("P1.xuxu"))
assert(m == P1.xuxu && m._NAME == "P1.xuxu" && AA == 0 && m.AA == 20);
assert(require("P1.xuxu") == P1.xuxu && P1.xuxu == m);
assert(require("P1.xuxu") == P1.xuxu);
assert(require("P1") == P1);
assert(P1.xuxu._PACKAGE == "P1.");
assert(P1.AA == 10 && P1._PACKAGE == "");
assert(P1._G == _G && P1.xuxu._G == _G);
removefiles(files);
package.path = ""
assert(!pcall(require, "file_does_not_exist"));
package.path = "??\0?"
assert(!pcall(require, "file_does_not_exist1"));
package.path = oldpath
local fname = "file_does_not_exist2"
local m, err = pcall(require, fname)
for t with string.gmatch(package.path .. ";" .. package.cpath, "[^;]+") {
t = string.gsub(t, "?", fname)
assert(string.find(err, t, 1, true));
}
local fn import(...) {
local f = {
...
}
return fn (m) {
for i = 1, #f {
m[(f[(i)])] = _G[(f[(i)])]
}
}
}
local assert, module, package = assert, module, package
X = nil
x = 0
assert(_G.x == 0);
module("X");
x = 1
assert(_M.x == 1);
module("X.a.b.c");
x = 2
assert(_M.x == 2);
module("X.a.b", package.seeall);
x = 3
assert(X._NAME == "X" && X.a.b.c._NAME == "X.a.b.c" && X.a.b._NAME == "X.a.b");
assert(X._M == X && X.a.b.c._M == X.a.b.c && X.a.b._M == X.a.b);
assert(X.x == 1 && X.a.b.c.x == 2 && X.a.b.x == 3);
assert(X._PACKAGE == "" && X.a.b.c._PACKAGE == "X.a.b." && X.a.b._PACKAGE == "X.a.");
assert(_PACKAGE .. "c" == "X.a.c");
assert(X.a._NAME == nil && X.a._M == nil);
module("X.a", import("X"));
x = 4
assert(X.a._NAME == "X.a" && X.a.x == 4 && X.a._M == X.a);
module("X.a.b", package.seeall);
assert(x == 3);
x = 5
assert(_NAME == "X.a.b" && X.a.b.x == 5);
assert(X._G == nil && X.a._G == nil && X.a.b._G == _G && X.a.b.c._G == nil);
setfenv(1, _G);
assert(x == 0);
assert(!pcall(module, "x"));
assert(!pcall(module, "math.sin"));
local p = ""
local f, err, when = package.loadlib("libs/lib1.so", p .. "luaopen_lib1")
if !f {
(Message || print)('\a\n >>> cannot load dynamic library <<<\n\a');
print(err, when);
} else {
f();
assert(require("lib1") == lib1);
collectgarbage();
assert(lib1.id("x") == "x");
f = assert(package.loadlib("libs/lib1.so", p .. "anotherfunc"))
assert(f(10, 20) == "1020\n");
f, err, when = package.loadlib("libs/lib1.so", p .. "xuxu")
assert(!f && type(err) == "string" && when == "init");
package.cpath = "libs/?.so"
require("lib2");
assert(lib2.id("x") == "x");
local fs = require("lib1.sub")
assert(fs == lib1.sub && next(lib1.sub) == nil);
module("lib2", package.seeall);
f = require("-lib2")
assert(f.id("x") == "x" && _M == f && _NAME == "lib2");
module("lib1.sub", package.seeall);
assert(_M == fs);
setfenv(1, _G);
}
f, err, when = package.loadlib("donotexist", p .. "xuxu")
assert(!f && type(err) == "string" && (when == "open" || when == "absent"));
{
local p = package
package = {}
p.preload.pl = fn (...) {
module(...);
global fn xuxu(x) {
return x + 20
}
}
require("pl");
assert(require("pl") == pl);
assert(pl.xuxu(10) == 30);
package = p
assert(type(package.path) == "string");
}
}
print('+');
print("testing assignments, logical operators, and constructors");
local res, res2 = 27
a, b = 1, 2 + 3
assert(a == 1 && b == 5);
a = {}
global fn f() {
return 10, 11, 12
}
a.x, b, a[(1)] = 1, 2, f()
assert(a.x == 1 && b == 2 && a[(1)] == 10);
a[(f())], b, a[(f() + 3)] = f(), a, 'x'
assert(a[(10)] == 10 && b == a && a[(13)] == 'x');
{
local f = fn (n) {
local x = {}
for i = 1, n {
x[(i)] = i
}
return unpack(x)
}
local a, b, c
a, b = 0, f(1)
assert(a == 0 && b == 1);
A, b = 0, f(1)
assert(A == 0 && b == 1);
a, b, c = 0, 5, f(4)
assert(a == 0 && b == 5 && c == 1);
a, b, c = 0, 5, f(0)
assert(a == 0 && b == 5 && c == nil);
}
a, b, c, d = 1 && nil, 1 || nil, (1 && (nil || 1)), 6
assert(!a && b && c && d == 6);
d = 20
a, b, c, d = f()
assert(a == 10 && b == 11 && c == 12 && d == nil);
a, b = f(), 1, 2, 3, f()
assert(a == 10 && b == 1);
assert(a < b == false && a > b == true);
assert((10 && 2) == 2);
assert((10 || 2) == 10);
assert((10 || assert(nil)) == 10);
assert(!(nil && assert(nil)));
assert((nil || "alo") == "alo");
assert((nil && 10) == nil);
assert((false && 10) == false);
assert((true || 10) == true);
assert((false || 10) == 10);
assert(false != nil);
assert(nil != false);
assert(!nil == true);
assert(!!nil == false);
assert(!!1 == true);
assert(!!a == true);
assert(!!(6 || nil) == true);
assert(!!(nil && 56) == false);
assert(!!(nil && true) == false);
print('+');
a = {}
a[(true)] = 20
a[(false)] = 10
assert(a[(1 < 2)] == 20 && a[(1 > 2)] == 10);
global fn f(a) {
return a
}
local a = {}
for i = 3000, -3000, -1 {
a[(i)] = i
}
a[(10e30)] = "alo"
a[(true)] = 10
a[(false)] = 20
assert(a[(10e30)] == 'alo' && a[(!1)] == 20 && a[(10 < 20)] == 10);
for i = 3000, -3000, -1 {
assert(a[(i)] == i);
}
a[(print)] = assert
a[(f)] = print
a[(a)] = a
assert(a[(a)][(a)][(a)][(a)][(print)] == assert);
a[(print)](a[(a[(f)])] == a[(print)]);
a = nil
a = {
10,
9,
8,
7,
6,
5,
4,
3,
2,
-3 = 'a',
f = print,
a = 'a',
b = 'ab'
}
a, a.x, a.y = a, a[(-3)]
assert(a[(1)] == 10 && a[(-3)] == a.a && a[(f)] == print && a.x == 'a' && !a.y);
a[(1)], f(a)[(2)], b, c = {
'alo' = assert
}, 10, a[(1)], a[(f)], 6, 10, 23, f(a), 2
a[(1)].alo(a[(2)] == 10 && b == 10 && c == print);
a[(2 ^ 31)] = 10
a[(2 ^ 31 + 1)] = 11
a[(-2 ^ 31)] = 12
a[(2 ^ 32)] = 13
a[(-2 ^ 32)] = 14
a[(2 ^ 32 + 1)] = 15
a[(10 ^ 33)] = 16
assert(a[(2 ^ 31)] == 10 && a[(2 ^ 31 + 1)] == 11 && a[(-2 ^ 31)] == 12 && a[(2 ^ 32)] == 13 && a[(-2 ^ 32)] == 14 && a[(2 ^ 32 + 1)] == 15 && a[(10 ^ 33)] == 16);
a = nil
{
local a, i, j, b
a = {
'a',
'b'
}
i = 1
j = 2
b = a
i, a[(i)], a, j, a[(j)], a[(i + j)] = j, i, i, b, j, i
assert(i == 2 && b[(1)] == 1 && a == 1 && j == b && b[(2)] == 2 && b[(3)] == 1);
}
print('OK');
return res