func TestLoadTheme(t *testing.T) {
type Test struct {
in string
out string
}
tests := []Test{
{
"testdata/Monokai.tmTheme",
"testdata/Monokai.tmTheme.res",
},
}
for _, test := range tests {
if d, err := ioutil.ReadFile(test.in); err != nil {
t.Logf("Couldn't load file %s: %s", test.in, err)
} else {
var theme Theme
if err := loaders.LoadPlist(d, &theme); err != nil {
t.Error(err)
} else {
str := fmt.Sprintf("%s", theme)
if d, err := ioutil.ReadFile(test.out); err != nil {
if err := ioutil.WriteFile(test.out, []byte(str), 0644); err != nil {
t.Error(err)
}
} else if diff := util.Diff(string(d), str); diff != "" {
t.Error(diff)
}
}
}
}
}
// This is not 100% what ST3 does, but IMO ST3 is wrong
func TestScopeName(t *testing.T) {
w := GetEditor().NewWindow()
defer w.Close()
v := w.NewFile()
defer func() {
v.SetScratch(true)
v.Close()
}()
const (
in = "textmate/testdata/main.go"
expfile = "testdata/scopename.res"
syntax = "textmate/testdata/Go.tmLanguage"
)
v.Settings().Set("syntax", syntax)
if d, err := ioutil.ReadFile(in); err != nil {
t.Fatal(err)
} else {
// v.rootNode = nil
e := v.BeginEdit()
v.Insert(e, 0, string(d))
v.EndEdit(e)
last := ""
str := ""
lasti := 0
for v.ScopeName(1) == "" {
time.Sleep(250 * time.Millisecond)
}
for i := 0; i < v.buffer.Size(); i++ {
if name := v.ScopeName(i); name != last {
if last != "" {
str += fmt.Sprintf("%d-%d: %s\n", lasti, i, last)
lasti = i
}
last = name
}
}
if i := v.Buffer().Size(); lasti != i {
str += fmt.Sprintf("%d-%d: %s\n", lasti, i, last)
}
if d, err := ioutil.ReadFile(expfile); err != nil {
if err := ioutil.WriteFile(expfile, []byte(str), 0644); err != nil {
t.Error(err)
}
} else if diff := util.Diff(string(d), str); diff != "" {
t.Error(diff)
}
}
}
// This is not 100% what ST3 does
func TestExtractScope(t *testing.T) {
w := GetEditor().NewWindow()
defer w.Close()
v := w.NewFile()
defer func() {
v.SetScratch(true)
v.Close()
}()
const (
in = "textmate/testdata/main.go"
expfile = "testdata/scoperange.res"
syntax = "textmate/testdata/Go.tmLanguage"
)
v.Settings().Set("syntax", syntax)
if d, err := ioutil.ReadFile(in); err != nil {
t.Fatal(err)
} else {
// v.rootNode = nil
e := v.BeginEdit()
v.Insert(e, 0, string(d))
v.EndEdit(e)
last := text.Region{A: -1, B: -1}
str := ""
nr := text.Region{A: 0, B: 0}
for v.ExtractScope(1) == nr {
time.Sleep(time.Millisecond)
}
for i := 0; i < v.buffer.Size(); i++ {
if r := v.ExtractScope(i); r != last {
str += fmt.Sprintf("%d (%d, %d)\n", i, r.A, r.B)
last = r
}
}
if d, err := ioutil.ReadFile(expfile); err != nil {
if err := ioutil.WriteFile(expfile, []byte(str), 0644); err != nil {
t.Error(err)
}
} else if diff := util.Diff(string(d), str); diff != "" {
t.Error(diff)
}
}
}
func TestTmLanguage(t *testing.T) {
files := []string{
"testdata/Property List (XML).tmLanguage",
"testdata/XML.plist",
"testdata/Go.tmLanguage",
}
for _, fn := range files {
if _, err := Provider.LanguageFromFile(fn); err != nil {
t.Fatal(err)
}
}
type test struct {
in string
out string
syn string
}
tests := []test{
{
"testdata/plist.tmlang",
"testdata/plist.tmlang.res",
"text.xml.plist",
},
{
"testdata/Property List (XML).tmLanguage",
"testdata/Property List (XML).tmLanguage.res",
"text.xml.plist",
},
{
"testdata/main.go",
"testdata/main.go.res",
"source.go",
},
{
"testdata/go2.go",
"testdata/go2.go.res",
"source.go",
},
{
"testdata/utf.go",
"testdata/utf.go.res",
"source.go",
},
}
for _, t3 := range tests {
var d0 string
if d, err := ioutil.ReadFile(t3.in); err != nil {
t.Errorf("Couldn't load file %s: %s", t3.in, err)
continue
} else {
d0 = string(d)
}
if lp, err := NewLanguageParser(t3.syn, d0); err != nil {
t.Error(err)
} else if root, err := lp.Parse(); err != nil {
t.Error(err)
} else {
// fmt.Println(lp.RootNode())
str := fmt.Sprintf("%s", root)
if d, err := ioutil.ReadFile(t3.out); err != nil {
if err := ioutil.WriteFile(t3.out, []byte(str), 0644); err != nil {
t.Error(err)
}
} else if diff := util.Diff(string(d), str); diff != "" {
t.Error(diff)
}
}
}
}
func TestSublime(t *testing.T) {
ed := backend.GetEditor()
ed.SetClipboardFuncs(func(n string) (err error) {
dummyClipboard = n
return nil
}, func() (string, error) {
return dummyClipboard, nil
})
ed.Init()
ed.Console().Buffer().AddObserver(&consoleObserver{T: t})
w := ed.NewWindow()
l := py.NewLock()
py.AddToPath("testdata")
py.AddToPath("testdata/plugins")
if m, err := py.Import("sublime_plugin"); err != nil {
t.Fatal(err)
} else {
plugins := packages.ScanPlugins("testdata/", ".py")
for _, p := range plugins {
newPlugin(p, m)
}
}
subl, err := py.Import("sublime")
if err != nil {
t.Fatal(err)
}
if w, err := _windowClass.Alloc(1); err != nil {
t.Fatal(err)
} else {
(w.(*Window)).data = &backend.Window{}
subl.AddObject("test_window", w)
}
// Testing plugin reload
data := []byte(`import sublime, sublime_plugin
class TestToxt(sublime_plugin.TextCommand):
def run(self, edit):
print("my view's id is: %d" % self.view.id())
self.view.insert(edit, 0, "Tada")
`)
if err := ioutil.WriteFile("testdata/plugins/reload.py", data, 0644); err != nil {
t.Fatalf("Couldn't write testdata/plugins/reload.py: %s", err)
}
defer os.Remove("testdata/plugins/reload.py")
time.Sleep(time.Millisecond * 50)
if dir, err := os.Open("testdata"); err != nil {
t.Error(err)
} else if files, err := dir.Readdirnames(0); err != nil {
t.Error(err)
} else {
for _, fn := range files {
// FIXME: Skip reload_test.py to work around #531 on OSX.
if fn == "reload_test.py" && ed.Platform() == "darwin" {
continue
}
if filepath.Ext(fn) == ".py" {
log.Debug("Running %s", fn)
if _, err := py.Import(fn[:len(fn)-3]); err != nil {
log.Error(err)
t.Error(err)
} else {
log.Debug("Ran %s", fn)
}
}
}
}
var f func(indent string, v py.Object, buf *bytes.Buffer)
f = func(indent string, v py.Object, buf *bytes.Buffer) {
b := v.Base()
if dir, err := b.Dir(); err != nil {
t.Error(err)
} else {
if l, ok := dir.(*py.List); ok {
sl := l.Slice()
if indent == "" {
for _, v2 := range sl {
if item, err := b.GetAttr(v2); err != nil {
t.Error(err)
} else {
ty := item.Type()
line := fmt.Sprintf("%s%s\n", indent, v2)
buf.WriteString(line)
if ty == py.TypeType {
f(indent+"\t", item, buf)
}
item.Decref()
}
}
} else {
for _, v2 := range sl {
buf.WriteString(fmt.Sprintf("%s%s\n", indent, v2))
}
}
} else {
ty := dir.Type()
t.Error("Unexpected type:", ty)
}
dir.Decref()
}
}
buf := bytes.NewBuffer(nil)
f("", subl, buf)
l.Unlock()
const expfile = "testdata/api.txt"
if d, err := ioutil.ReadFile(expfile); err != nil {
if err := ioutil.WriteFile(expfile, buf.Bytes(), 0644); err != nil {
t.Error(err)
}
} else if diff := util.Diff(string(d), buf.String()); diff != "" {
t.Error(diff)
}
ed.LogCommands(true)
tests := []string{
"state",
"registers",
"settings",
"constants",
"registers",
"cmd_data",
"marks",
}
for _, test := range tests {
ed.CommandHandler().RunWindowCommand(w, "vintage_ex_run_data_file_based_tests", backend.Args{"suite_name": test})
}
for _, w := range ed.Windows() {
for _, v := range w.Views() {
if strings.HasSuffix(v.Buffer().FileName(), "sample.txt") {
continue
}
if strings.Index(v.Buffer().Substr(text.Region{A: 0, B: v.Buffer().Size()}), "FAILED") != -1 {
t.Error(v.Buffer())
}
}
}
var v *backend.View
for _, v2 := range w.Views() {
if v == nil || v2.Buffer().Size() > v.Buffer().Size() {
v = v2
}
}
}