func Test_TypeData_Primitive(t *testing.T) {
allTypes := []string{
"void", "boolean", "byte", "char", "short",
"int", "long", "float", "double", "string",
}
for _, str := range allTypes {
for dim := 0; dim < 5; dim++ {
td := NewTypeDataPrimitive(str, dim)
_, is_nil := td.TypeName()
testutil.AssertEqual(t, dim == 0 && strings.EqualFold(str, "void"), is_nil,
str, "should not be nil", is_nil)
var expStr string
switch str {
case "boolean":
expStr = "bool"
case "short":
expStr = "int16"
case "long":
expStr = "int64"
case "float":
expStr = "float32"
case "double":
expStr = "float64"
default:
expStr = str
}
for i := 1; i <= dim; i++ {
expStr = "[]" + expStr
}
testutil.AssertEqual(t, td.String(), expStr, "Expected", expStr,
"not", td.String())
testutil.AssertFalse(t, td.isObject(), "Unexpected object", str)
}
}
defer func() {
if x := recover(); x != nil {
testutil.AssertEqual(t, x, "Unrecognized primitive type xxx")
}
}()
td := NewTypeDataPrimitive("xxx", 0)
testutil.AssertNotNil(t, td, "Got nil TypeData for bad primitive type")
}
func validate(t *testing.T, str string, dim int, td *TypeData,
fd *FakeDictionary) {
vt, is_nil := td.TypeName()
testutil.AssertEqual(t, dim == 0 && strings.EqualFold(str, "void"), is_nil,
str, "should not be nil", is_nil)
if !is_nil {
testutil.AssertNotNil(t, vt, str, "dim", dim, "is nil ::", vt)
}
expName := str
if dim == 0 {
expName = str
} else {
var star string
if fd != nil && !fd.IsInterface(str) {
star = "*"
}
expName = fmt.Sprintf("array_%s%s_dim%d", star, str, dim)
}
testutil.AssertEqual(t, expName, td.Name(), "Expected name", expName,
"not", td.Name())
var expStr string
if fd == nil || fd.IsInterface(str) {
expStr = str
} else {
expStr = "*" + str
}
for i := 1; i <= dim; i++ {
expStr = "[]" + expStr
}
testutil.AssertEqual(t, expStr, td.String(), "Expected string ", expStr,
"not", td.String())
if fd != nil {
if dim == 0 {
testutil.AssertTrue(t, td.isObject(), "Expected object", str)
} else {
testutil.AssertFalse(t, td.isObject(), "Unexpected object", str)
}
}
}
func Test_GoProgram_Basic(t *testing.T) {
name := "foo"
gp := NewGoProgram(name, nil, false)
gp.Analyze(nil)
rcvr := gp.Receiver("foo")
testutil.AssertEqual(t, rcvr, "rcvr", "Expected rcvr, not", rcvr)
imap := gp.Imports()
testutil.AssertNotNil(t, imap, "ImportMap() should not return nil")
testutil.AssertEqual(t, len(imap), 0, "Did not expect ImportMap to contain", imap)
decls := gp.Decls()
testutil.AssertNotNil(t, decls, "Decls() should not return nil")
testutil.AssertEqual(t, len(decls), 0, "Did not expect Decls to contain", decls)
dout := &bytes.Buffer{}
gp.Dump(dout)
dstr := dout.String()
expDstr := "package main\n"
testutil.AssertEqual(t, dstr, expDstr, "Expected '", expDstr, "' not '", dstr, "'")
file := gp.File()
testutil.AssertNotNil(t, file, "File() should not return nil")
testutil.AssertNotNil(t, file.Name, "File.Name should not be nil")
testutil.AssertNotNil(t, file.Name.Name, "main",
"File.Name.Name should be", "main", file.Name.Name)
testutil.AssertNotNil(t, file.Decls, "File.Decls() should not return nil")
testutil.AssertEqual(t, len(file.Decls), 0,
"Did not expect File.Decls to contain", file.Decls)
testutil.AssertNotNil(t, file.Imports, "File.Imports() should not return nil")
testutil.AssertEqual(t, len(file.Imports), 0,
"Did not expect File.Imports to contain", file.Imports)
testutil.AssertEqual(t, len(file.Unresolved), 0,
"File.Unresolved should be empty but contains", len(file.Unresolved),
"entries")
testutil.AssertEqual(t, len(file.Comments), 0,
"File.Comments should be empty but contains", len(file.Comments),
"entries")
fs := gp.FileSet()
fmt.Printf("FileSet -> %v\n", fs)
sout := &bytes.Buffer{}
gp.WriteString(sout)
fmt.Printf("File -> %v\n", sout.String())
}
func Test_Simple(t *testing.T) {
pgm := "public class foo{ private int val;" +
" public int getVal() { return val; }" +
" public foo(int val) { this.val = val; }" +
"}"
rdr := NewStringReader(pgm)
lx := NewLexer(rdr, false)
rtn := JulyParse(lx)
testutil.AssertEqual(t, rtn, 0, "Expected", 0, "not", rtn)
}
func Test_Config_Full(t *testing.T) {
name := fillFile(t)
cfg := ReadConfig(name)
var pkg string
pkg = cfg.packageName("a.b")
testutil.AssertEqual(t, pkg, "ab")
pkg = cfg.packageName("a.b.c")
testutil.AssertEqual(t, pkg, "abc")
var is_iface bool
is_iface = cfg.isInterface("a.b.DEF")
testutil.AssertTrue(t, is_iface, "a.b.DEF is not an interface")
is_iface = cfg.isInterface("a.b.GHI")
testutil.AssertTrue(t, is_iface, "a.b.GHI is not an interface")
var rcvr string
rcvr = cfg.receiver("a.b.XXX")
testutil.AssertEqual(t, rcvr, "xxx")
rcvr = cfg.receiver("a.b.ZZZ")
testutil.AssertEqual(t, rcvr, "zzz")
}
func Test_FixName(t *testing.T) {
raw := "NaMe"
modmap := make(map[string]string)
modmap["public"] = "NaMe"
modmap["protected"] = "NaMe"
modmap["private"] = "naMe"
for modtype, fixed := range modmap {
jmod := grammar.NewJModifiers(modtype, nil)
nm := fixName(raw, jmod)
testutil.AssertEqual(t, nm, fixed, "For modtype", modtype, "expected", fixed,
"not", nm)
}
}
func Test_Main(t *testing.T) {
src := "public class foo\n" +
"{\n" +
" private int val;\n" +
" public int getVal() { return val; }\n" +
" public foo(int val) { this.val = val; }\n" +
" public static final void main(String[] args) {\n" +
" for (int i = 0; i < args.length; i++) {\n" +
" System.out.println(\"Arg#\" + i + \"=\" + args[i]);\n" +
" System.err.printf(\"Arg#%d=%s\\n\", i, args[i]);\n" +
" }\n" +
" }\n" +
"}\n"
rdr := grammar.NewStringReader(src)
lx := grammar.NewLexer(rdr, false)
rtn := grammar.JulyParse(lx)
testutil.AssertEqual(t, rtn, 0, "Expected", 0, "not", rtn)
testutil.AssertNotNil(t, lx.JavaProgram(), "Parser did not return Java parse tree")
pgm := NewGoProgram("", nil, false)
pgm.Analyze(lx.JavaProgram())
fmt.Println("========= PARSE TREE =============")
pgm.WriteString(os.Stdout)
fmt.Println()
for _, rule := range StandardRules {
pgm.RunTransform(rule, pgm, nil, nil)
}
fmt.Println("========= FINAL PROGRAM =============")
pgm.Dump(os.Stdout)
}
