diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/lang/go')
10 files changed, 680 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py b/packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py new file mode 100644 index 000000000000..cbd244a7e056 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/expressions/TestExpressions.py @@ -0,0 +1,113 @@ +"""Test the go expression parser/interpreter.""" + +import os, time +import unittest2 +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +class TestGoUserExpression(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @add_test_categories(['pyapi']) + @skipIfRemote # Not remote test suit ready + @skipUnlessGoInstalled + def test_with_dsym_and_python_api(self): + """Test GoASTUserExpress.""" + self.buildGo() + self.launchProcess() + self.go_expressions() + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers to break inside main(). + self.main_source = "main.go" + self.break_line = line_number(self.main_source, '// Set breakpoint here.') + + def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin): + tl = self.target().FindTypes(name) + self.assertEqual(1, len(tl)) + t = list(tl)[0] + self.assertEqual(name, t.name) + self.assertEqual(typeclass, t.type) + if size > 0: + self.assertEqual(size, t.size) + + def launchProcess(self): + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) + self.assertTrue(bpt, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) + + # Make sure we stopped at the first breakpoint. + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + frame = thread_list[0].GetFrameAtIndex(0) + self.assertTrue (frame, "Got a valid frame 0 frame.") + + def go_expressions(self): + frame = self.frame() + v = frame.EvaluateExpression("1") + self.assertEqual(1, v.GetValueAsSigned()) + x = frame.EvaluateExpression("x") + self.assertEqual(22, x.GetValueAsSigned()) + + a = frame.EvaluateExpression("a") + self.assertEqual(3, a.GetNumChildren()) + a0 = a.GetChildAtIndex(0) + self.assertEqual(8, a0.GetValueAsSigned()) + + # Array indexing + a0 = frame.EvaluateExpression("a[0]") + self.assertEqual(8, a0.GetValueAsSigned()) + + # Slice indexing + b1 = frame.EvaluateExpression("b[1]") + self.assertEqual(9, b1.GetValueAsSigned()) + + # Test global in this package + g = frame.EvaluateExpression("myGlobal") + self.assertEqual(17, g.GetValueAsSigned(), str(g)) + + # Global with package name + g = frame.EvaluateExpression("main.myGlobal") + self.assertEqual(17, g.GetValueAsSigned(), str(g)) + + # Global with quoted package name + g = frame.EvaluateExpression('"main".myGlobal') + self.assertEqual(17, g.GetValueAsSigned(), str(g)) + + # Casting with package local type + s = frame.EvaluateExpression("*(*myStruct)(i.data)") + sb = s.GetChildMemberWithName("a") + self.assertEqual(2, sb.GetValueAsSigned()) + + # casting with explicit package + s = frame.EvaluateExpression("*(*main.myStruct)(i.data)") + sb = s.GetChildMemberWithName("a") + self.assertEqual(2, sb.GetValueAsSigned()) + + # Casting quoted package + s = frame.EvaluateExpression('*(*"main".myStruct)(i.data)') + sb = s.GetChildMemberWithName("b") + self.assertEqual(-1, sb.GetValueAsSigned()) + +if __name__ == '__main__': + import atexit + lldb.SBDebugger.Initialize() + atexit.register(lambda: lldb.SBDebugger.Terminate()) + unittest2.main() diff --git a/packages/Python/lldbsuite/test/lang/go/expressions/main.go b/packages/Python/lldbsuite/test/lang/go/expressions/main.go new file mode 100644 index 000000000000..c8b97fe07d7d --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/expressions/main.go @@ -0,0 +1,21 @@ +package main + +import "fmt" + +type myStruct struct { + a, b int +} + +var myGlobal = 17 + +func myFunc(i interface{}) { + a := [...]int{8, 9, 10} + b := a[:] + x := 22 + fmt.Println(a, b, x, i, myGlobal) // Set breakpoint here. +} + +func main() { + s := myStruct {2, -1} + myFunc(s) +}
\ No newline at end of file diff --git a/packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py b/packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py new file mode 100644 index 000000000000..8b869df4ef8f --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/formatters/TestGoFormatters.py @@ -0,0 +1,65 @@ +"""Test the Go Data Formatter Plugin.""" + +import os, time +import unittest2 +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +class TestGoLanguage(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure + @skipIfRemote # Not remote test suite ready + @no_debug_info_test + @skipUnlessGoInstalled + def test_go_formatter_plugin(self): + """Test go data formatters.""" + self.buildGo() + self.launchProcess() + self.check_formatters() + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers to break inside main(). + self.main_source = "main.go" + self.break_line = line_number(self.main_source, '// stop here') + + def launchProcess(self): + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + self.bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) + self.assertTrue(self.bpt, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, self.bpt) + + # Make sure we stopped at the first breakpoint. + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + frame = thread_list[0].GetFrameAtIndex(0) + self.assertTrue (frame, "Got a valid frame 0 frame.") + + def check_formatters(self): + a = self.frame().FindVariable('a') + self.assertEqual('(string) a = "my string"', str(a)) + b = self.frame().FindVariable('b') + self.assertEqual("([]int) b = (len 2, cap 7) {\n [0] = 0\n [1] = 0\n}", str(b)) + + +if __name__ == '__main__': + import atexit + lldb.SBDebugger.Initialize() + atexit.register(lambda: lldb.SBDebugger.Terminate()) + unittest2.main() diff --git a/packages/Python/lldbsuite/test/lang/go/formatters/main.go b/packages/Python/lldbsuite/test/lang/go/formatters/main.go new file mode 100644 index 000000000000..7956ad66bcb4 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/formatters/main.go @@ -0,0 +1,9 @@ +package main + +import "fmt" + +func main() { + a := "my string" + b := make([]int, 2, 7) + fmt.Println(a, b) // stop here +}
\ No newline at end of file diff --git a/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py b/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py new file mode 100644 index 000000000000..35961ebd1d92 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/goroutines/TestGoroutines.py @@ -0,0 +1,85 @@ +"""Test the Go OS Plugin.""" + +from __future__ import print_function + + + +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +class TestGoASTContext(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @add_test_categories(['pyapi']) + @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure + @skipIfRemote # Not remote test suite ready + @no_debug_info_test + @skipUnlessGoInstalled + def test_goroutine_plugin(self): + """Test goroutine as threads support.""" + self.buildGo() + self.launchProcess() + self.check_goroutines() + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers to break inside main(). + self.main_source = "main.go" + self.break_line1 = line_number(self.main_source, '// stop1') + self.break_line2 = line_number(self.main_source, '// stop2') + self.break_line3 = line_number(self.main_source, '// stop3') + + def launchProcess(self): + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + self.bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1) + self.assertTrue(self.bpt1, VALID_BREAKPOINT) + self.bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2) + self.assertTrue(self.bpt2, VALID_BREAKPOINT) + self.bpt3 = target.BreakpointCreateByLocation(self.main_source, self.break_line3) + self.assertTrue(self.bpt3, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, self.bpt1) + + # Make sure we stopped at the first breakpoint. + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + frame = thread_list[0].GetFrameAtIndex(0) + self.assertTrue (frame, "Got a valid frame 0 frame.") + + def check_goroutines(self): + self.assertLess(len(self.process().threads), 20) + self.process().Continue() + + # Make sure we stopped at the 2nd breakpoint + thread_list = lldbutil.get_threads_stopped_at_breakpoint (self.process(), self.bpt2) + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + # There's (at least) 21 goroutines. + self.assertGreater(len(self.process().threads), 20) + # self.dbg.HandleCommand("log enable lldb os") + + # Now test that stepping works if the memory thread moves to a different backing thread. + for i in list(range(11)): + self.thread().StepOver() + self.assertEqual(lldb.eStopReasonPlanComplete, self.thread().GetStopReason(), self.thread().GetStopDescription(100)) + + # Disable the plugin and make sure the goroutines disappear + self.dbg.HandleCommand("settings set plugin.os.goroutines.enable false") + self.thread().StepInstruction(False) + self.assertLess(len(self.process().threads), 20) diff --git a/packages/Python/lldbsuite/test/lang/go/goroutines/main.go b/packages/Python/lldbsuite/test/lang/go/goroutines/main.go new file mode 100644 index 000000000000..bb44f7b8b716 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/goroutines/main.go @@ -0,0 +1,89 @@ +package main + +import ( + "fmt" + "runtime" +) + +type philosopher struct { + i int + forks [2]chan bool + eating chan int + done chan struct{} +} + +func (p philosopher) run() { + for { + select { + case <-p.done: + return + case <-p.forks[0]: + p.eat() + } + } +} + +func (p philosopher) eat() { + select { + case <-p.done: + return + case <-p.forks[1]: + p.eating <- p.i + p.forks[0] <- true + p.forks[1] <- true + runtime.Gosched() + } +} + +func startPhilosophers(n int) (chan struct{}, chan int) { + philosophers := make([]*philosopher, n) + chans := make([]chan bool, n) + for i := range chans { + chans[i] = make(chan bool, 1) + chans[i] <- true + } + eating := make(chan int, n) + done := make(chan struct{}) + for i := range philosophers { + var min, max int + if i == n - 1 { + min = 0 + max = i + } else { + min = i + max = i + 1 + } + philosophers[i] = &philosopher{i: i, forks: [2]chan bool{chans[min], chans[max]}, eating: eating, done: done} + go philosophers[i].run() + } + return done, eating +} + +func wait(c chan int) { + fmt.Println(<- c) + runtime.Gosched() +} + +func main() { + // Restrict go to 1 real thread so we can be sure we're seeing goroutines + // and not threads. + runtime.GOMAXPROCS(1) + // Create a bunch of goroutines + done, eating := startPhilosophers(20) // stop1 + // Now turn up the number of threads so this goroutine is likely to get + // scheduled on a different thread. + runtime.GOMAXPROCS(runtime.NumCPU()) // stop2 + // Now let things run. Hopefully we'll bounce around + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + wait(eating) + close(done) + fmt.Println("done") // stop3 +} diff --git a/packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime b/packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime new file mode 100644 index 000000000000..44797077a641 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/runtime/TestGoLanguageRuntime @@ -0,0 +1,80 @@ +"""Test the go dynamic type handling.""" + +import os, time +import unittest2 +import lldb +import lldbutil +from lldbtest import * + +class TestGoLanguageRuntime(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @python_api_test + @expectedFailureFreeBSD('llvm.org/pr24895') + @skipIfRemote # Not remote test suite ready + @skipUnlessGoInstalled + def test_with_dsym_and_python_api(self): + """Test GoASTContext dwarf parsing.""" + self.buildGo() + self.launchProcess() + self.go_interface_types() + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers to break inside main(). + self.main_source = "main.go" + self.break_line1 = line_number(self.main_source, '// Set breakpoint 1') + self.break_line2 = line_number(self.main_source, '// Set breakpoint 2') + + + def launchProcess(self): + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + bpt1 = target.BreakpointCreateByLocation(self.main_source, self.break_line1) + self.assertTrue(bpt1, VALID_BREAKPOINT) + bpt2 = target.BreakpointCreateByLocation(self.main_source, self.break_line2) + self.assertTrue(bpt2, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt1) + + # Make sure we stopped at the first breakpoint. + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + frame = thread_list[0].GetFrameAtIndex(0) + self.assertTrue (frame, "Got a valid frame 0 frame.") + + def go_interface_types(self): + f = self.frame() + v = f.FindVariable("a", lldb.eDynamicCanRunTarget) + self.assertEqual("*int", v.GetType().name) + self.assertEqual(1, v.Dereference().GetValueAsSigned()) + v = f.FindVariable("b", lldb.eDynamicCanRunTarget) + self.assertEqual("*float64", v.GetType().name) + err = lldb.SBError() + self.assertEqual(2.0, v.Dereference().GetData().GetDouble(err, 0)) + v = f.FindVariable("c", lldb.eDynamicCanRunTarget) + self.assertEqual("*main.SomeFooer", v.GetType().name) + self.assertEqual(9, v.Dereference().GetChildAtIndex(0).GetValueAsSigned()) + v = f.FindVariable("d", lldb.eDynamicCanRunTarget) + self.assertEqual("*main.AnotherFooer", v.GetType().name) + self.assertEqual(-1, v.Dereference().GetChildAtIndex(0).GetValueAsSigned()) + self.assertEqual(-2, v.Dereference().GetChildAtIndex(1).GetValueAsSigned()) + self.assertEqual(-3, v.Dereference().GetChildAtIndex(2).GetValueAsSigned()) + +if __name__ == '__main__': + import atexit + lldb.SBDebugger.Initialize() + atexit.register(lambda: lldb.SBDebugger.Terminate()) + unittest2.main() diff --git a/packages/Python/lldbsuite/test/lang/go/runtime/main.go b/packages/Python/lldbsuite/test/lang/go/runtime/main.go new file mode 100644 index 000000000000..227c8c377ed7 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/runtime/main.go @@ -0,0 +1,38 @@ +package main + +import "fmt" + +type Fooer interface { + Foo() int +} + +type SomeFooer struct { + val int +} + +func (s SomeFooer) Foo() int { + return s.val +} + +type AnotherFooer struct { + a, b, c int +} + +func (s AnotherFooer) Foo() int { + return s.a +} + + +func printEface(a, b, c, d interface{}) { + fmt.Println(a, b, c, d) // Set breakpoint 1 +} + +func printIface(a, b Fooer) { + fmt.Println(a, b) // Set breakpoint 2 +} +func main() { + sf := SomeFooer{9} + af := AnotherFooer{-1, -2, -3} + printEface(1,2.0, sf, af) + printIface(sf, af) +}
\ No newline at end of file diff --git a/packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py b/packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py new file mode 100644 index 000000000000..8da31e9e81f7 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/types/TestGoASTContext.py @@ -0,0 +1,133 @@ +"""Test the go DWARF type parsing.""" + +from __future__ import print_function + + + +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +class TestGoASTContext(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @add_test_categories(['pyapi']) + @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure + @skipIfRemote # Not remote test suit ready + @no_debug_info_test + @skipUnlessGoInstalled + def test_with_dsym_and_python_api(self): + """Test GoASTContext dwarf parsing.""" + self.buildGo() + self.launchProcess() + self.go_builtin_types() + self.check_main_vars() + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers to break inside main(). + self.main_source = "main.go" + self.break_line = line_number(self.main_source, '// Set breakpoint here.') + + def check_builtin(self, name, size=0, typeclass=lldb.eTypeClassBuiltin): + tl = self.target().FindTypes(name) + self.assertEqual(1, len(tl)) + t = list(tl)[0] + self.assertEqual(name, t.name) + self.assertEqual(typeclass, t.type) + if size > 0: + self.assertEqual(size, t.size) + + def launchProcess(self): + exe = os.path.join(os.getcwd(), "a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + bpt = target.BreakpointCreateByLocation(self.main_source, self.break_line) + self.assertTrue(bpt, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, bpt) + + # Make sure we stopped at the first breakpoint. + self.assertTrue (len(thread_list) != 0, "No thread stopped at our breakpoint.") + self.assertTrue (len(thread_list) == 1, "More than one thread stopped at our breakpoint.") + + frame = thread_list[0].GetFrameAtIndex(0) + self.assertTrue (frame, "Got a valid frame 0 frame.") + + def go_builtin_types(self): + address_size = self.target().GetAddressByteSize() + self.check_builtin('bool') + self.check_builtin('uint8', 1) + self.check_builtin('int8', 1) + self.check_builtin('uint16', 2) + self.check_builtin('int16', 2) + self.check_builtin('uint32', 4) + self.check_builtin('int32', 4) + self.check_builtin('uint64', 8) + self.check_builtin('int64', 8) + self.check_builtin('uintptr', address_size) + self.check_builtin('int', address_size) + self.check_builtin('uint', address_size) + self.check_builtin('float32', 4) + self.check_builtin('float64', 8) + self.check_builtin('complex64', 8, lldb.eTypeClassComplexFloat) + self.check_builtin('complex128', 16, lldb.eTypeClassComplexFloat) + + def var(self, name): + var = self.frame().FindVariable(name) + self.assertTrue(var.IsValid(), "%s %s" % (VALID_VARIABLE, name)) + return var + + def check_main_vars(self): + v = self.var('theBool') + self.assertEqual('true', v.value) + + v = self.var('theInt') + self.assertEqual('-7', v.value) + + v = self.var('theComplex') + self.assertEqual('1 + 2i', v.value) + + v = self.var('thePointer') + self.assertTrue(v.TypeIsPointerType()) + self.assertEqual('-10', v.Dereference().value) + self.assertEqual(1, v.GetNumChildren()) + self.assertEqual('-10', v.GetChildAtIndex(0).value) + + # print() + # print(os.getpid()) + # time.sleep(60) + v = self.var('theStruct') + if v.TypeIsPointerType(): + v = v.Dereference() + self.assertEqual(2, v.GetNumChildren()) + self.assertEqual('7', v.GetChildAtIndex(0).value) + self.assertEqual('7', v.GetChildMemberWithName('myInt').value) + self.assertEqual(v.load_addr, v.GetChildAtIndex(1).GetValueAsUnsigned()) + self.assertEqual(v.load_addr, v.GetChildMemberWithName('myPointer').GetValueAsUnsigned()) + + # Test accessing struct fields through pointers. + v = v.GetChildMemberWithName('myPointer') + self.assertTrue(v.TypeIsPointerType()) + self.assertEqual(2, v.GetNumChildren()) + self.assertEqual('7', v.GetChildAtIndex(0).value) + c = v.GetChildMemberWithName('myPointer') + self.assertTrue(c.TypeIsPointerType()) + self.assertEqual(2, c.GetNumChildren()) + self.assertEqual('7', c.GetChildAtIndex(0).value) + + v = self.var('theArray') + self.assertEqual(5, v.GetNumChildren()) + for i in list(range(5)): + self.assertEqual(str(i + 1), v.GetChildAtIndex(i).value) diff --git a/packages/Python/lldbsuite/test/lang/go/types/main.go b/packages/Python/lldbsuite/test/lang/go/types/main.go new file mode 100644 index 000000000000..c74650721d7d --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/go/types/main.go @@ -0,0 +1,47 @@ +package main + +import "fmt" + +type Fooer interface { + Foo() int +} + +type SomeFooer struct { + val int +} + +func (s SomeFooer) Foo() int { + return s.val +} + +type mystruct struct { + myInt int + myPointer *mystruct +} + +func main() { + theBool := true + theInt := -7 + theComplex := 1 + 2i + pointee := -10 + thePointer := &pointee + theStruct := &mystruct { myInt: 7} + theStruct.myPointer = theStruct + theArray := [5]byte{1, 2, 3, 4, 5} + theSlice := theArray[1:2] + theString := "abc" + + f := SomeFooer {9} + var theEface interface{} = f + var theFooer Fooer = f + + theChan := make(chan int) + theMap := make(map[int]string) + theMap[1] = "1" + + fmt.Println(theBool) // Set breakpoint here. + // Reference all the variables so the compiler is happy. + fmt.Println(theInt, theComplex, thePointer, theStruct.myInt) + fmt.Println(theArray[0], theSlice[0], theString) + fmt.Println(theEface, theFooer, theChan, theMap) +}
\ No newline at end of file |