func TestOsOpen(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
om := new(OsMod)
om.SetCtx(ctx)
fn := "./testdata/readfile.txt"
f := om.os_Open(runtime.String(fn))
fl := f.(*file)
ret := fl.Get(runtime.String("Name"))
if ret.String() != fn {
t.Errorf("expected Name to be '%s', got '%s'", fn, ret)
}
exp := "ok"
ret = fl.readLine()
if ret.String() != exp {
t.Errorf("expected read line 1 to be '%s', got '%s'", exp, ret)
}
exp = ""
ret = fl.readLine()
if ret.String() != exp {
t.Errorf("expected read line 2 to be '%s', got '%s'", exp, ret)
}
ret = fl.readLine()
if ret != runtime.Nil {
t.Errorf("expected read line 3 to be nil, got '%v'", ret)
}
ret = fl.closeFile()
if ret != runtime.Nil {
t.Errorf("expected close file to be nil, got '%v'", ret)
}
}
// Args:
// 0 - The string
// 1 - The regexp pattern
// 2 - (optional) a maximum number of matches to return
//
// Returns:
// An object holding all the matches, or nil if no match.
// Each match contains:
// n - The nth match group (when n=0, the full text of the match)
// Each match group contains:
// start - the index of the start of the match
// end - the end of the match
// text - the string of the match
func (s *StringsMod) strings_Matches(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(2, args)
src := args[0].String()
rx := regexp.MustCompile(args[1].String())
n := -1 // By default, return all matches
if len(args) > 2 {
n = int(args[2].Int())
}
strmtch := rx.FindAllStringSubmatch(src, n)
if strmtch == nil {
return runtime.Nil
}
ixmtch := rx.FindAllStringSubmatchIndex(src, n)
ob := runtime.NewObject()
for i, mtches := range strmtch {
obch := runtime.NewObject()
for j, mtch := range mtches {
leaf := runtime.NewObject()
leaf.Set(runtime.String("Text"), runtime.String(mtch))
leaf.Set(runtime.String("Start"), runtime.Number(ixmtch[i][2*j]))
leaf.Set(runtime.String("End"), runtime.Number(ixmtch[i][2*j+1]))
obch.Set(runtime.Number(j), leaf)
}
ob.Set(runtime.Number(i), obch)
}
return ob
}
func TestStringsSplit(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_Split(runtime.String("aa:bb::dd"), runtime.String(":"))
ob := ret.(runtime.Object)
exp := []string{"aa", "bb", "", "dd"}
if l := ob.Len().Int(); l != int64(len(exp)) {
t.Errorf("expected split length of %d, got %d", len(exp), l)
}
for i, v := range exp {
got := ob.Get(runtime.Number(i))
if got.String() != v {
t.Errorf("expected split index %d to be %s, got %s", i, v, got)
}
}
ret = sm.strings_Split(runtime.String("aa:bb::dd:ee:"), runtime.String(":"), runtime.Number(2))
ob = ret.(runtime.Object)
exp = []string{"aa", "bb::dd:ee:"}
if l := ob.Len().Int(); l != int64(len(exp)) {
t.Errorf("expected split length of %d, got %d", len(exp), l)
}
for i, v := range exp {
got := ob.Get(runtime.Number(i))
if got.String() != v {
t.Errorf("expected split index %d to be %s, got %s", i, v, got)
}
}
}
func createFileInfo(fi os.FileInfo) runtime.Val {
o := runtime.NewObject()
o.Set(runtime.String("Name"), runtime.String(fi.Name()))
o.Set(runtime.String("Size"), runtime.Number(fi.Size()))
o.Set(runtime.String("IsDir"), runtime.Bool(fi.IsDir()))
return o
}
func TestOsFields(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
om := new(OsMod)
om.SetCtx(ctx)
ob, err := om.Run()
if err != nil {
panic(err)
}
{
ob := ob.(runtime.Object)
ret := ob.Get(runtime.String("PathSeparator"))
exp := string(os.PathSeparator)
if ret.String() != exp {
t.Errorf("expected path separator %s, got %s", exp, ret.String())
}
ret = ob.Get(runtime.String("PathListSeparator"))
exp = string(os.PathListSeparator)
if ret.String() != exp {
t.Errorf("expected path list separator %s, got %s", exp, ret.String())
}
ret = ob.Get(runtime.String("DevNull"))
exp = os.DevNull
if ret.String() != exp {
t.Errorf("expected dev/null %s, got %s", exp, ret)
}
ret = ob.Get(runtime.String("TempDir"))
exp = os.TempDir()
if ret.String() != exp {
t.Errorf("expected temp dir %s, got %s", exp, ret)
}
}
}
func TestFilepathBaseDirExt(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
fm := new(FilepathMod)
fm.SetCtx(ctx)
p, e := filepath.Abs("./testdata/readfile.txt")
if e != nil {
panic(e)
}
// Base
exp := filepath.Base(p)
ret := fm.filepath_Base(runtime.String(p))
if ret.String() != exp {
t.Errorf("expected base '%s', got '%s'", exp, ret.String())
}
// Dir
exp = filepath.Dir(p)
ret = fm.filepath_Dir(runtime.String(p))
if ret.String() != exp {
t.Errorf("expected dir '%s', got '%s'", exp, ret.String())
}
// Ext
exp = filepath.Ext(p)
ret = fm.filepath_Ext(runtime.String(p))
if ret.String() != exp {
t.Errorf("expected extension '%s', got '%s'", exp, ret.String())
}
}
func TestTimeConv(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
tm := new(TimeMod)
tm.SetCtx(ctx)
nw := time.Now().UTC()
n := tm.time_Date(runtime.Number(nw.Year()),
runtime.Number(nw.Month()),
runtime.Number(nw.Day()),
runtime.Number(nw.Hour()),
runtime.Number(nw.Minute()),
runtime.Number(nw.Second()),
runtime.Number(nw.Nanosecond()))
ob := n.(runtime.Object)
cnv := ob.Get(runtime.String("__string"))
f := cnv.(runtime.Func)
ret := f.Call(nil)
exp := nw.Format(time.RFC3339)
if ret.String() != exp {
t.Errorf("expected string to return '%s', got '%s'", exp, ret)
}
cnv = ob.Get(runtime.String("__int"))
f = cnv.(runtime.Func)
ret = f.Call(nil)
{
exp := nw.Unix()
if ret.Int() != int64(exp) {
t.Errorf("expected int to return %d, got %d", exp, ret.Int())
}
}
}
func TestStringsTrim(t *testing.T) {
cases := []struct {
args []runtime.Val
exp string
}{
0: {
args: []runtime.Val{
runtime.String(" "),
},
exp: "",
},
1: {
args: []runtime.Val{
runtime.String("\n \t hi \r"),
},
exp: "hi",
},
2: {
args: []runtime.Val{
runtime.String("xoxolovexox"),
runtime.String("xo"),
},
exp: "love",
},
}
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
for i, c := range cases {
ret := sm.strings_Trim(c.args...)
if ret.String() != c.exp {
t.Errorf("[%d] - expected %s, got %s", i, c.exp, ret)
}
}
}
func TestMin(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
mm := new(MathMod)
mm.SetCtx(ctx)
cases := []struct {
src []runtime.Val
exp runtime.Val
}{
0: {
src: []runtime.Val{runtime.Number(3), runtime.Number(0), runtime.Number(-12.74), runtime.Number(1)},
exp: runtime.Number(-12.74),
},
1: {
src: []runtime.Val{runtime.String("24"), runtime.Bool(true), runtime.Number(12.74)},
exp: runtime.Number(1),
},
2: {
src: []runtime.Val{runtime.Number(0), runtime.String("0")},
exp: runtime.Number(0),
},
}
for i, c := range cases {
ret := mm.math_Min(c.src...)
if ret != c.exp {
t.Errorf("[%d] - expected %f, got %f", i, c.exp.Float(), ret.Float())
}
}
}
func (v *agoraVec) sub(args ...runtime.Val) runtime.Val {
v2 := args[0].Native().(*agoraVec)
x := v.Get(runtime.String("X")).Float()
y := v.Get(runtime.String("Y")).Float()
x2 := v2.Get(runtime.String("X")).Float()
y2 := v2.Get(runtime.String("Y")).Float()
return v.jm.newVec(x-x2, y-y2)
}
// Args:
// 0 - The source string
// 1 - The 0-based index number
//
// Returns:
// The character at that position, as a string, or an empty string if
// the index is out of bounds.
func (s *StringsMod) strings_ByteAt(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(2, args)
src := args[0].String()
at := int(args[1].Int())
if at < 0 || at >= len(src) {
return runtime.String("")
}
return runtime.String(src[at])
}
func TestStringsToUpper(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_ToUpper(runtime.String("this"), runtime.String("Is"), runtime.String("A"), runtime.String("... strInG"))
exp := "THISISA... STRING"
if ret.String() != exp {
t.Errorf("expected %s, got %s", exp, ret)
}
}
func TestOsExec(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
om := new(OsMod)
om.SetCtx(ctx)
exp := "hello"
ret := om.os_Exec(runtime.String("echo"), runtime.String(exp))
// Shell adds a \n after output
if ret.String() != exp+"\n" {
t.Errorf("expected '%s', got '%s'", exp, ret)
}
}
func (t *TimeMod) Run(_ ...runtime.Val) (v runtime.Val, err error) {
defer runtime.PanicToError(&err)
if t.ob == nil {
// Prepare the object
t.ob = runtime.NewObject()
t.ob.Set(runtime.String("Date"), runtime.NewNativeFunc(t.ctx, "time.Date", t.time_Date))
t.ob.Set(runtime.String("Now"), runtime.NewNativeFunc(t.ctx, "time.Now", t.time_Now))
t.ob.Set(runtime.String("Sleep"), runtime.NewNativeFunc(t.ctx, "time.Sleep", t.time_Sleep))
}
return t.ob, nil
}
func (f *FmtMod) Run(_ ...runtime.Val) (v runtime.Val, err error) {
defer runtime.PanicToError(&err)
if f.ob == nil {
// Prepare the object
f.ob = runtime.NewObject()
f.ob.Set(runtime.String("Print"), runtime.NewNativeFunc(f.ctx, "fmt.Print", f.fmt_Print))
f.ob.Set(runtime.String("Println"), runtime.NewNativeFunc(f.ctx, "fmt.Println", f.fmt_Println))
f.ob.Set(runtime.String("Scanln"), runtime.NewNativeFunc(f.ctx, "fmt.Scanln", f.fmt_Scanln))
f.ob.Set(runtime.String("Scanint"), runtime.NewNativeFunc(f.ctx, "fmt.Scanint", f.fmt_Scanint))
}
return f.ob, nil
}
func TestStringsHasSuffix(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_HasSuffix(runtime.String("suffix, you say"), runtime.String("ay"), runtime.Nil, runtime.Number(3), runtime.String("wh"))
if !ret.Bool() {
t.Errorf("expected true, got false")
}
ret = sm.strings_HasSuffix(runtime.String("suffix, you say"), runtime.String("no"), runtime.Nil, runtime.Number(3), runtime.String("hw"))
if ret.Bool() {
t.Errorf("expected false, got true")
}
}
func TestStringsContains(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_Contains(runtime.String("contains something"), runtime.String("what"), runtime.Nil, runtime.Number(3), runtime.String("some"))
if !ret.Bool() {
t.Errorf("expected true, got false")
}
ret = sm.strings_Contains(runtime.String("contains something"), runtime.String("no"), runtime.Nil, runtime.Number(3), runtime.String("hw"))
if ret.Bool() {
t.Errorf("expected false, got true")
}
}
func (jm *JotaModule) newVec(x, y float64) *agoraVec {
ob := runtime.NewObject()
v := &agoraVec{
Object: ob,
jm: jm,
}
ob.Set(runtime.String("Length"), runtime.NewNativeFunc(jm.ctx, "jota.Vec.Length", v.length))
ob.Set(runtime.String("Sub"), runtime.NewNativeFunc(jm.ctx, "jota.Vec.Sub", v.sub))
ob.Set(runtime.String("Angle"), runtime.NewNativeFunc(jm.ctx, "jota.Vec.Angle", v.angle))
ob.Set(runtime.String("X"), runtime.Number(x))
ob.Set(runtime.String("Y"), runtime.Number(y))
return v
}
func TestStringsLastIndex(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_LastIndex(runtime.String("agoragore"), runtime.String("arg"), runtime.Nil, runtime.Number(3), runtime.String("go"))
exp := 5
if ret.Int() != int64(exp) {
t.Errorf("expected %d, got %d", exp, ret.Int())
}
ret = sm.strings_Index(runtime.String("agoragore"), runtime.Number(6), runtime.String("arg"), runtime.Nil, runtime.Number(3), runtime.String("go"))
exp = -1
if ret.Int() != int64(exp) {
t.Errorf("expected %d, got %d", exp, ret.Int())
}
}
func TestStringsSlice(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
ret := sm.strings_Slice(runtime.String("agora"), runtime.Number(2))
exp := "ora"
if ret.String() != exp {
t.Errorf("expected %s, got %s", exp, ret)
}
ret = sm.strings_Slice(runtime.String("agora"), runtime.Number(2), runtime.Number(4))
exp = "or"
if ret.String() != exp {
t.Errorf("expected %s, got %s", exp, ret)
}
}
func TestStringsReplace(t *testing.T) {
cases := []struct {
args []runtime.Val
exp string
}{
0: {
args: []runtime.Val{
runtime.String("this is the source"),
runtime.String("th"),
},
exp: "is is e source",
},
1: {
args: []runtime.Val{
runtime.String("this is the source"),
runtime.String("th"),
runtime.Number(1),
},
exp: "is is the source",
},
2: {
args: []runtime.Val{
runtime.String("this is the source"),
runtime.String("t"),
runtime.String("T"),
},
exp: "This is The source",
},
3: {
args: []runtime.Val{
runtime.String("this is the source"),
runtime.String("t"),
runtime.String("T"),
runtime.Number(1),
},
exp: "This is the source",
},
}
ctx := runtime.NewCtx(nil, nil)
sm := new(StringsMod)
sm.SetCtx(ctx)
for i, c := range cases {
ret := sm.strings_Replace(c.args...)
if ret.String() != c.exp {
t.Errorf("[%d] - expected %s, got %s", i, c.exp, ret)
}
}
}
func (o *OsMod) os_Getwd(args ...runtime.Val) runtime.Val {
pwd, err := os.Getwd()
if err != nil {
panic(err)
}
return runtime.String(pwd)
}
func (jm *JotaModule) Param(vs ...runtime.Val) runtime.Val {
jm.dieOnTerminated()
jm.paramsMutex.Lock()
defer jm.paramsMutex.Unlock()
paramName := vs[0].String()
value, ok := jm.params[paramName]
if !ok {
return runtime.Nil
}
switch t := value.(type) {
case string:
return runtime.String(t)
case bool:
return runtime.Bool(t)
case int:
return runtime.Number(t)
case float64:
return runtime.Number(t)
case linear.Vec2:
return jm.newVec(t.X, t.Y)
case game.Gid:
return jm.newEnt(t)
default:
base.Error().Printf("Requested parameter of unexpected type: %T", t)
return runtime.Nil
}
}
func (o *OsMod) os_ReadFile(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(1, args)
b, e := ioutil.ReadFile(args[0].String())
if e != nil {
panic(e)
}
return runtime.String(b)
}
func (fp *FilepathMod) filepath_Abs(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(1, args)
s, e := filepath.Abs(args[0].String())
if e != nil {
panic(e)
}
return runtime.String(s)
}
func TestTimeNow(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
tm := new(TimeMod)
tm.SetCtx(ctx)
exp := time.Now()
ret := tm.time_Now()
ob := ret.(runtime.Object)
if yr := ob.Get(runtime.String("Year")); yr.Int() != int64(exp.Year()) {
t.Errorf("expected year %d, got %d", exp.Year(), yr.Int())
}
if mt := ob.Get(runtime.String("Month")); mt.Int() != int64(exp.Month()) {
t.Errorf("expected month %d, got %d", exp.Month(), mt.Int())
}
if dy := ob.Get(runtime.String("Day")); dy.Int() != int64(exp.Day()) {
t.Errorf("expected day %d, got %d", exp.Day(), dy.Int())
}
if hr := ob.Get(runtime.String("Hour")); hr.Int() != int64(exp.Hour()) {
t.Errorf("expected hour %d, got %d", exp.Hour(), hr.Int())
}
if mn := ob.Get(runtime.String("Minute")); mn.Int() != int64(exp.Minute()) {
t.Errorf("expected minute %d, got %d", exp.Minute(), mn.Int())
}
if sc := ob.Get(runtime.String("Second")); sc.Int() != int64(exp.Second()) {
t.Errorf("expected second %d, got %d", exp.Second(), sc.Int())
}
if ns := ob.Get(runtime.String("Nanosecond")); ns.Int() < int64(exp.Nanosecond()) {
t.Errorf("expected nanosecond %d, got %d", exp.Nanosecond(), ns.Int())
}
}
func (o *OsMod) os_Exec(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(1, args)
c := exec.Command(args[0].String(), toString(args[1:])...)
b, e := c.CombinedOutput()
if e != nil {
panic(e)
}
return runtime.String(b)
}
// Args:
// 0 - the source string
// 1 [optional] - the cutset (all leading and trailing characters in this string will be
// removed). Defaults to whitespace (space, \n, \t, \v and \r).
// Returns:
// The trimmed string.
func (s *StringsMod) strings_Trim(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(1, args)
src := args[0].String()
cut := " \n\t\v\r"
if len(args) > 1 {
cut = args[1].String()
}
return runtime.String(strings.Trim(src, cut))
}
// Slice a string to get a substring. Basically the same as slicing in Go.
// Args:
// 0 - The source string
// 1 - The start index
// 2 [optional] - The high bound, such that the length of the resulting string is high-start
// Results:
// The sliced string.
func (s *StringsMod) strings_Slice(args ...runtime.Val) runtime.Val {
runtime.ExpectAtLeastNArgs(2, args)
src := args[0].String()
start := args[1].Int()
end := len(src)
if len(args) > 2 {
end = int(args[2].Int())
}
return runtime.String(src[start:end])
}
func TestOsTryOpen(t *testing.T) {
ctx := runtime.NewCtx(nil, nil)
om := new(OsMod)
om.SetCtx(ctx)
// With an unknown file
fn := "./testdata/unknown.txt"
ret := om.os_TryOpen(runtime.String(fn))
if ret != runtime.Nil {
t.Errorf("expected unknown file to return nil, got '%v'", ret)
}
// With an existing file
fn = "./testdata/readfile.txt"
ret = om.os_TryOpen(runtime.String(fn))
if fl, ok := ret.(*file); !ok {
t.Errorf("expected existing file to return *file, got '%T'", ret)
} else {
fl.closeFile()
}
}