func TestCanUseDefFromImport(t *testing.T) { assert := assert.New(t) ds := datas.NewDataStore(chunks.NewMemoryStore()) dir, err := ioutil.TempDir("", "") assert.NoError(err) defer os.RemoveAll(dir) byPathNomDL := filepath.Join(dir, "filedep.noms") err = ioutil.WriteFile(byPathNomDL, []byte("struct FromFile{i:Int8}"), 0600) assert.NoError(err) r1 := strings.NewReader(` struct A { B: B } struct B { X: Int64 }`) pkg1 := pkg.ParseNomDL("test1", r1, dir, ds) pkgRef1 := ds.WriteValue(pkg1.Package).TargetRef() r2 := strings.NewReader(fmt.Sprintf(` alias Other = import "%s" struct C { C: Map<Int64, Other.A> } `, pkgRef1)) pkg2 := pkg.ParseNomDL("test2", r2, dir, ds) gen2 := newCodeGen(nil, "test2", "go", map[string]bool{}, depsMap{pkg1.Ref(): pkg1.Package}, pkg2) assert.True(gen2.canUseDef(pkg2.Types()[0], gen2.pkg.Package)) }
func parsePackageFile(packageName string, in string, pkgDS dataset.Dataset) pkg.Parsed { inFile, err := os.Open(in) d.Chk.NoError(err) defer inFile.Close() return pkg.ParseNomDL(packageName, inFile, filepath.Dir(in), pkgDS.Store()) }
func assertOutput(inPath, lang, goldenPath string, t *testing.T) { assert := assert.New(t) emptyDS := datas.NewDataStore(chunks.NewMemoryStore()) // Will be DataStore containing imports depsDir, err := ioutil.TempDir("", "") assert.NoError(err) defer os.RemoveAll(depsDir) inFile, err := os.Open(inPath) assert.NoError(err) defer inFile.Close() goldenFile, err := os.Open(goldenPath) assert.NoError(err) defer goldenFile.Close() goldenBytes, err := ioutil.ReadAll(goldenFile) d.Chk.NoError(err) var buf bytes.Buffer pkg := pkg.ParseNomDL("gen", inFile, filepath.Dir(inPath), emptyDS) written := map[string]bool{} gen := newCodeGen(&buf, getBareFileName(inPath), lang, written, depsMap{}, pkg) gen.WritePackage() bs := buf.Bytes() if lang == "go" { bs, err = imports.Process("", bs, nil) d.Chk.NoError(err) } assert.Equal(string(goldenBytes), string(bs), "%s did not generate the same string", inPath) }
func TestCanUseDef(t *testing.T) { assert := assert.New(t) emptyDS := datas.NewDataStore(chunks.NewMemoryStore()) depsDir, err := ioutil.TempDir("", "") assert.NoError(err) defer os.RemoveAll(depsDir) assertCanUseDef := func(s string, using, named bool) { pkg := pkg.ParseNomDL("fakefile", bytes.NewBufferString(s), "", emptyDS) gen := newCodeGen(nil, "fakefile", "go", map[string]bool{}, depsMap{}, pkg) for _, t := range pkg.UsingDeclarations { assert.Equal(using, gen.canUseDef(t, gen.pkg.Package)) } for _, t := range pkg.Types() { assert.Equal(named, gen.canUseDef(t, gen.pkg.Package)) } } good := ` using List<Int8> using Set<Int8> using Map<Int8, Int8> using Map<Int8, Set<Int8>> using Map<Int8, Map<Int8, Int8>> struct Simple { x: Int8 } using Set<Simple> using Map<Simple, Int8> using Map<Simple, Simple> ` assertCanUseDef(good, true, true) good = ` struct Tree { children: List<Tree> } ` assertCanUseDef(good, true, true) bad := ` struct WithList { x: List<Int8> } using Set<WithList> using Map<WithList, Int8> struct WithSet { x: Set<Int8> } using Set<WithSet> using Map<WithSet, Int8> struct WithMap { x: Map<Int8, Int8> } using Set<WithMap> using Map<WithMap, Int8> ` assertCanUseDef(bad, false, true) bad = ` struct Commit { value: Value parents: Set<Commit> } ` assertCanUseDef(bad, false, false) bad = ` Set<Set<Int8>> Set<Map<Int8, Int8>> Set<List<Int8>> Map<Set<Int8>, Int8> Map<Map<Int8, Int8>, Int8> Map<List<Int8>, Int8> ` for _, line := range strings.Split(bad, "\n") { if strings.TrimSpace(line) == "" { continue } assertCanUseDef(fmt.Sprintf("using %s", line), false, false) assertCanUseDef(fmt.Sprintf("struct S { x: %s }", line), false, false) } }