Merging other languages
This commit is contained in:
James Miranda
513
en/11.2.md
513
en/11.2.md
@@ -1,249 +1,264 @@
|
||||
# 11.2 使用GDB调试
|
||||
开发程序过程中调试代码是开发者经常要做的一件事情，Go语言不像PHP、Python等动态语言，只要修改不需要编译就可以直接输出，而且可以动态的在运行环境下打印数据。当然Go语言也可以通过Println之类的打印数据来调试，但是每次都需要重新编译，这是一件相当麻烦的事情。我们知道在Python中有pdb/ipdb之类的工具调试，Javascript也有类似工具，这些工具都能够动态的显示变量信息，单步调试等。不过庆幸的是Go也有类似的工具支持：GDB。Go内部已经内置支持了GDB，所以，我们可以通过GDB来进行调试，那么本小节就来介绍一下如何通过GDB来调试Go程序。
|
||||
|
||||
## GDB调试简介
|
||||
GDB是FSF(自由软件基金会)发布的一个强大的类UNIX系统下的程序调试工具。使用GDB可以做如下事情：
|
||||
|
||||
1. 启动程序，可以按照开发者的自定义要求运行程序。
|
||||
2. 可让被调试的程序在开发者设定的调置的断点处停住。（断点可以是条件表达式）
|
||||
3. 当程序被停住时，可以检查此时程序中所发生的事。
|
||||
4. 动态的改变当前程序的执行环境。
|
||||
|
||||
目前支持调试Go程序的GDB版本必须大于7.1。
|
||||
|
||||
编译Go程序的时候需要注意以下几点
|
||||
|
||||
1. 传递参数-ldflags "-s"，忽略debug的打印信息
|
||||
2. 传递-gcflags "-N -l" 参数，这样可以忽略Go内部做的一些优化，聚合变量和函数等优化，这样对于GDB调试来说非常困难，所以在编译的时候加入这两个参数避免这些优化。
|
||||
|
||||
## 常用命令
|
||||
GDB的一些常用命令如下所示
|
||||
|
||||
- list
|
||||
|
||||
简写命令`l`，用来显示源代码，默认显示十行代码，后面可以带上参数显示的具体行，例如：`list 15`，显示十行代码，其中第15行在显示的十行里面的中间，如下所示。
|
||||
|
||||
10 time.Sleep(2 * time.Second)
|
||||
11 c <- i
|
||||
12 }
|
||||
13 close(c)
|
||||
14 }
|
||||
15
|
||||
16 func main() {
|
||||
17 msg := "Starting main"
|
||||
18 fmt.Println(msg)
|
||||
19 bus := make(chan int)
|
||||
|
||||
|
||||
- break
|
||||
|
||||
简写命令 `b`,用来设置断点，后面跟上参数设置断点的行数，例如`b 10`在第十行设置断点。
|
||||
|
||||
- delete
|
||||
简写命令 `d`,用来删除断点，后面跟上断点设置的序号，这个序号可以通过`info breakpoints`获取相应的设置的断点序号，如下是显示的设置断点序号。
|
||||
|
||||
Num Type Disp Enb Address What
|
||||
2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xiemengjun/gdb.go:23
|
||||
breakpoint already hit 1 time
|
||||
|
||||
- backtrace
|
||||
|
||||
简写命令 `bt`,用来打印执行的代码过程，如下所示：
|
||||
|
||||
#0 main.main () at /home/xiemengjun/gdb.go:23
|
||||
#1 0x000000000040d61e in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
|
||||
#2 0x000000000040d6c1 in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
|
||||
#3 0x0000000000000000 in ?? ()
|
||||
- info
|
||||
|
||||
info命令用来显示信息，后面有几种参数，我们常用的有如下几种：
|
||||
|
||||
- `info locals`
|
||||
|
||||
显示当前执行的程序中的变量值
|
||||
- `info breakpoints`
|
||||
|
||||
显示当前设置的断点列表
|
||||
- `info goroutines`
|
||||
|
||||
显示当前执行的goroutine列表，如下代码所示,带*的表示当前执行的
|
||||
|
||||
* 1 running runtime.gosched
|
||||
* 2 syscall runtime.entersyscall
|
||||
3 waiting runtime.gosched
|
||||
4 runnable runtime.gosched
|
||||
- print
|
||||
|
||||
简写命令`p`，用来打印变量或者其他信息，后面跟上需要打印的变量名，当然还有一些很有用的函数$len()和$cap()，用来返回当前string、slices或者maps的长度和容量。
|
||||
|
||||
- whatis
|
||||
|
||||
用来显示当前变量的类型，后面跟上变量名，例如`whatis msg`,显示如下：
|
||||
|
||||
type = struct string
|
||||
- next
|
||||
|
||||
简写命令 `n`,用来单步调试，跳到下一步，当有断点之后，可以输入`n`跳转到下一步继续执行
|
||||
- coutinue
|
||||
|
||||
简称命令 `c`，用来跳出当前断点处，后面可以跟参数N，跳过多少次断点
|
||||
|
||||
- set variable
|
||||
|
||||
该命令用来改变运行过程中的变量值，格式如：`set variable <var>=<value>`
|
||||
|
||||
## 调试过程
|
||||
我们通过下面这个代码来演示如何通过GDB来调试Go程序，下面是将要演示的代码：
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func counting(c chan<- int) {
|
||||
for i := 0; i < 10; i++ {
|
||||
time.Sleep(2 * time.Second)
|
||||
c <- i
|
||||
}
|
||||
close(c)
|
||||
}
|
||||
|
||||
func main() {
|
||||
msg := "Starting main"
|
||||
fmt.Println(msg)
|
||||
bus := make(chan int)
|
||||
msg = "starting a gofunc"
|
||||
go counting(bus)
|
||||
for count := range bus {
|
||||
fmt.Println("count:", count)
|
||||
}
|
||||
}
|
||||
|
||||
编译文件，生成可执行文件gdbfile:
|
||||
|
||||
go build -gcflags "-N -l" gdbfile.go
|
||||
|
||||
通过gdb命令启动调试：
|
||||
|
||||
gdb gdbfile
|
||||
|
||||
启动之后首先看看这个程序是不是可以运行起来，只要输入`run`命令回车后程序就开始运行，程序正常的话可以看到程序输出如下，和我们在命令行直接执行程序输出是一样的：
|
||||
|
||||
(gdb) run
|
||||
Starting program: /home/xiemengjun/gdbfile
|
||||
Starting main
|
||||
count: 0
|
||||
count: 1
|
||||
count: 2
|
||||
count: 3
|
||||
count: 4
|
||||
count: 5
|
||||
count: 6
|
||||
count: 7
|
||||
count: 8
|
||||
count: 9
|
||||
[LWP 2771 exited]
|
||||
[Inferior 1 (process 2771) exited normally]
|
||||
好了，现在我们已经知道怎么让程序跑起来了，接下来开始给代码设置断点：
|
||||
|
||||
(gdb) b 23
|
||||
Breakpoint 1 at 0x400d8d: file /home/xiemengjun/gdbfile.go, line 23.
|
||||
(gdb) run
|
||||
Starting program: /home/xiemengjun/gdbfile
|
||||
Starting main
|
||||
[New LWP 3284]
|
||||
[Switching to LWP 3284]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
上面例子`b 23`表示在第23行设置了断点，之后输入`run`开始运行程序。现在程序在前面设置断点的地方停住了，我们需要查看断点相应上下文的源码，输入`list`就可以看到源码显示从当前停止行的前五行开始：
|
||||
|
||||
(gdb) list
|
||||
18 fmt.Println(msg)
|
||||
19 bus := make(chan int)
|
||||
20 msg = "starting a gofunc"
|
||||
21 go counting(bus)
|
||||
22 for count := range bus {
|
||||
23 fmt.Println("count:", count)
|
||||
24 }
|
||||
25 }
|
||||
|
||||
现在GDB在运行当前的程序的环境中已经保留了一些有用的调试信息，我们只需打印出相应的变量，查看相应变量的类型及值：
|
||||
|
||||
(gdb) info locals
|
||||
count = 0
|
||||
bus = 0xf840001a50
|
||||
(gdb) p count
|
||||
$1 = 0
|
||||
(gdb) p bus
|
||||
$2 = (chan int) 0xf840001a50
|
||||
(gdb) whatis bus
|
||||
type = chan int
|
||||
|
||||
接下来该让程序继续往下执行，请继续看下面的命令
|
||||
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 0
|
||||
[New LWP 3303]
|
||||
[Switching to LWP 3303]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 1
|
||||
[Switching to LWP 3302]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
每次输入`c`之后都会执行一次代码，又跳到下一次for循环，继续打印出来相应的信息。
|
||||
|
||||
设想目前需要改变上下文相关变量的信息，跳过一些过程，并继续执行下一步，得出修改后想要的结果：
|
||||
|
||||
(gdb) info locals
|
||||
count = 2
|
||||
bus = 0xf840001a50
|
||||
(gdb) set variable count=9
|
||||
(gdb) info locals
|
||||
count = 9
|
||||
bus = 0xf840001a50
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 9
|
||||
[Switching to LWP 3302]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
最后稍微思考一下，前面整个程序运行的过程中到底创建了多少个goroutine，每个goroutine都在做什么：
|
||||
|
||||
(gdb) info goroutines
|
||||
* 1 running runtime.gosched
|
||||
* 2 syscall runtime.entersyscall
|
||||
3 waiting runtime.gosched
|
||||
4 runnable runtime.gosched
|
||||
(gdb) goroutine 1 bt
|
||||
#0 0x000000000040e33b in runtime.gosched () at /home/xiemengjun/go/src/pkg/runtime/proc.c:927
|
||||
#1 0x0000000000403091 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
|
||||
at /home/xiemengjun/go/src/pkg/runtime/chan.c:327
|
||||
#2 0x000000000040316f in runtime.chanrecv2 (t=void, c=void)
|
||||
at /home/xiemengjun/go/src/pkg/runtime/chan.c:420
|
||||
#3 0x0000000000400d6f in main.main () at /home/xiemengjun/gdbfile.go:22
|
||||
#4 0x000000000040d0c7 in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
|
||||
#5 0x000000000040d16a in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
|
||||
#6 0x0000000000000000 in ?? ()
|
||||
|
||||
通过查看goroutines的命令我们可以清楚地了解goruntine内部是怎么执行的，每个函数的调用顺序已经明明白白地显示出来了。
|
||||
|
||||
## 小结
|
||||
本小节我们介绍了GDB调试Go程序的一些基本命令，包括`run`、`print`、`info`、`set variable`、`coutinue`、`list`、`break` 等经常用到的调试命令，通过上面的例子演示，我相信读者已经对于通过GDB调试Go程序有了基本的理解，如果你想获取更多的调试技巧请参考官方网站的GDB调试手册，还有GDB官方网站的手册。
|
||||
|
||||
## links
|
||||
* [目录](<preface.md>)
|
||||
* 上一节: [错误处理](<11.1.md>)
|
||||
* 下一节: [Go怎么写测试用例](<11.3.md>)
|
||||
# 11.2 Debugging with GDB
|
||||
|
||||
During the development process of any application, developers will always need to perform some kind of code debugging. PHP, Python, and most of the other dynamic languages, are able to be modified at runtime, as long as the modifications do not explicitly need to be compiled. We can easily print data in dynamic operating environments, outputting our changes and printing variable information directly. In Go, you can of course speckle your code with `Println`s before-hand to display variable information for debugging purposes, but any changes to your code need to be recompiled every time. This can quickly become cumbersome. If you've programmed in Python or Javascript, you'll know that the former provides tools such as pdb and ipdb for debugging, and the latter has similar tools that are able to dynamically display variable information and facilitate single-step debugging. Fortunately, Go has native support for a similar tool which provides such debugging features: GDB. This section serves as a brief introduction into debugging Go applications using GDB.
|
||||
|
||||
## GDB debugging profile
|
||||
|
||||
GDB is a powerful debugging tool targeting UNIX-like systems, released by the FSF (Free Software Foundation). GDB allows us to do the following things:
|
||||
|
||||
1. Initial settings can be customize according to the specific requirements of your application.
|
||||
2. Can be set so that the program being debugged in the developer's console stops at the prescribed breakpoints (breakpoints can be conditional expressions).
|
||||
3. When the program has been stopped, you can check its current state to see what happened.
|
||||
4. Dynamically change the current program's execution environment.
|
||||
|
||||
To debug your Go applications using GDB, the version of GDB you use must be greater than 7.1.
|
||||
|
||||
When compiling Go programs, the following points require particular attention:
|
||||
|
||||
1. Using `-ldflags "-s"` will prevent the standard debugging information from being printed
|
||||
2. Using `-gcflags "-N-l"` will prevent Go from performing some of its automated optimizations -optimizations of aggregate variables, functions, etc. These optimizations can make it very difficult for GDB to do its job, so it's best to disable them at compile time using these flags.
|
||||
|
||||
Some of GDB's most commonly used commands are as follows:
|
||||
|
||||
- list
|
||||
|
||||
Also used in its abbreviated form `l`, `list` is used to display the source code. By default, it displays ten lines of code and you can specify the line you wish to display. For example, the command `list 15` displays ten lines of code centered around line 15, as shown below.
|
||||
|
||||
10 time.Sleep(2 * time.Second)
|
||||
11 c <- i
|
||||
12 }
|
||||
13 close(c)
|
||||
14 }
|
||||
15
|
||||
16 func main() {
|
||||
17 msg := "Starting main"
|
||||
18 fmt.Println(msg)
|
||||
19 bus := make(chan int)
|
||||
|
||||
- break
|
||||
|
||||
Also used in its abbreviated form `b`, `break` is used to set breakpoints, and takes as an argument that defines which point to set the breakpoint at. For example, `b 10` sets a break point at the tenth row.
|
||||
|
||||
- delete
|
||||
|
||||
Also used in its abbreviated form `d`, `delete` is used to delete break points. The break point is set followed by the serial number. The serial number can be obtained through the `info breakpoints` command. Break points set with their corresponding serial numbers are displayed as follows to set a break point number.
|
||||
|
||||
Num Type Disp Enb Address What
|
||||
2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xiemengjun/gdb.go:23
|
||||
breakpoint already hit 1 time
|
||||
|
||||
- backtrace
|
||||
|
||||
Abbreviated as `bt`, this command is used to print the execution of the code, for instance:
|
||||
|
||||
#0 main.main () at /home/xiemengjun/gdb.go:23
|
||||
#1 0x000000000040d61e in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
|
||||
#2 0x000000000040d6c1 in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
|
||||
#3 0x0000000000000000 in ?? ()
|
||||
|
||||
- info
|
||||
|
||||
The `info` command can be used in conjunction with several parameters to display information. The following parameters are commonly used:
|
||||
|
||||
- `info locals`
|
||||
|
||||
Displays the currently executing program's variable values
|
||||
|
||||
- `info breakpoints`
|
||||
|
||||
Displays a list of currently set breakpoints
|
||||
|
||||
- `info goroutines`
|
||||
|
||||
Displays the current list of running goroutines, as shown in the following code, with the `*` indicating the current execution
|
||||
|
||||
* 1 running runtime.gosched
|
||||
* 2 syscall runtime.entersyscall
|
||||
3 waiting runtime.gosched
|
||||
4 runnable runtime.gosched
|
||||
|
||||
- print
|
||||
|
||||
Abbreviated as `p`, this command is used to print variables or other information. It takes as arguments the variable names to be printed and of course, there are some very useful functions such as $len() and $cap() that can be used to return the length or capacity of the current strings, slices or maps.
|
||||
|
||||
- whatis
|
||||
|
||||
`whatis` is used to display the current variable type, followed by the variable name. For instance, `whatis msg`, will output the following:
|
||||
|
||||
type = struct string
|
||||
|
||||
- next
|
||||
|
||||
Abbreviated as `n`, `next` is used in single-step debugging to skip to the next step. When there is a break point, you can enter `n` to jump to the next step to continue
|
||||
|
||||
- continue
|
||||
|
||||
Abbreviated as `c`, `continue` is used to jump out of the current break point and can be followed by a parameter N, which specifies the number of times to skip the break point
|
||||
|
||||
- set variable
|
||||
|
||||
This command is used to change the value of a variable in the process. It can be used like so: `set variable <var> = <value>`
|
||||
|
||||
## The debugging process
|
||||
|
||||
Now, let's take a look at the following code to see how GDB is typically used to debug Go programs:
|
||||
|
||||
|
||||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func counting(c chan<- int) {
|
||||
for i := 0; i < 10; i++ {
|
||||
time.Sleep(2 * time.Second)
|
||||
c <- i
|
||||
}
|
||||
close(c)
|
||||
}
|
||||
|
||||
func main() {
|
||||
msg := "Starting main"
|
||||
fmt.Println(msg)
|
||||
bus := make(chan int)
|
||||
msg = "starting a gofunc"
|
||||
go counting(bus)
|
||||
for count := range bus {
|
||||
fmt.Println("count:", count)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Now we compile the file, creating an executable file called "gdbfile":
|
||||
|
||||
go build -gcflags "-N -l" gdbfile.go
|
||||
|
||||
Use the GDB command to start debugging :
|
||||
|
||||
gdb gdbfile
|
||||
|
||||
After first starting GDB, you'll have to enter the `run` command to see your program running. You will then see the program output the following; executing the program directly from the command line will output exactly the same thing:
|
||||
|
||||
(gdb) run
|
||||
Starting program: /home/xiemengjun/gdbfile
|
||||
Starting main
|
||||
count: 0
|
||||
count: 1
|
||||
count: 2
|
||||
count: 3
|
||||
count: 4
|
||||
count: 5
|
||||
count: 6
|
||||
count: 7
|
||||
count: 8
|
||||
count: 9
|
||||
[LWP 2771 exited]
|
||||
[Inferior 1 (process 2771) exited normally]
|
||||
|
||||
Ok, now that we know how to get the program up and running, let's take a look at setting breakpoints:
|
||||
|
||||
(gdb) b 23
|
||||
Breakpoint 1 at 0x400d8d: file /home/xiemengjun/gdbfile.go, line 23.
|
||||
(gdb) run
|
||||
Starting program: /home/xiemengjun/gdbfile
|
||||
Starting main
|
||||
[New LWP 3284]
|
||||
[Switching to LWP 3284]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
|
||||
In the above example, we use the `b 23` command to set a break point on line 23 of our code, then enter `run` to start the program. When our program stops at our breakpoint, we typically need to look at the corresponding source code context. Entering the `list` command into our GDB session, we can see the five lines of code preceding our breakpoint:
|
||||
|
||||
(gdb) list
|
||||
18 fmt.Println(msg)
|
||||
19 bus := make(chan int)
|
||||
20 msg = "starting a gofunc"
|
||||
21 go counting(bus)
|
||||
22 for count := range bus {
|
||||
23 fmt.Println("count:", count)
|
||||
24 }
|
||||
25 }
|
||||
|
||||
Now that GDB is running the current program environment, we have access to some useful debugging information that we can print out. To see the corresponding variable types and values, type `info locals`:
|
||||
|
||||
(gdb) info locals
|
||||
count = 0
|
||||
bus = 0xf840001a50
|
||||
(gdb) p count
|
||||
$1 = 0
|
||||
(gdb) p bus
|
||||
$2 = (chan int) 0xf840001a50
|
||||
(gdb) whatis bus
|
||||
type = chan int
|
||||
|
||||
To let the program continue its execution until the next breakpoint, enter the `c` command:
|
||||
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 0
|
||||
[New LWP 3303]
|
||||
[Switching to LWP 3303]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 1
|
||||
[Switching to LWP 3302]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
|
||||
After each `c`, the code will execute once then jump to the next iteration of the `for` loop. It will, of course, continue to print out the appropriate information.
|
||||
|
||||
Let's say that you need to change the context variables in the current execution environment, skip the process then continue to the next step. You can do so by first using `info locals` to get the variable states, then the `set variable` command to modify them:
|
||||
|
||||
(gdb) info locals
|
||||
count = 2
|
||||
bus = 0xf840001a50
|
||||
(gdb) set variable count=9
|
||||
(gdb) info locals
|
||||
count = 9
|
||||
bus = 0xf840001a50
|
||||
(gdb) c
|
||||
Continuing.
|
||||
count: 9
|
||||
[Switching to LWP 3302]
|
||||
|
||||
Breakpoint 1, main.main () at /home/xiemengjun/gdbfile.go:23
|
||||
23 fmt.Println("count:", count)
|
||||
|
||||
Finally, while running, the program creates a number of number goroutines. We can see what each goroutine is doing using `info goroutines`:
|
||||
|
||||
(gdb) info goroutines
|
||||
* 1 running runtime.gosched
|
||||
* 2 syscall runtime.entersyscall
|
||||
3 waiting runtime.gosched
|
||||
4 runnable runtime.gosched
|
||||
(gdb) goroutine 1 bt
|
||||
#0 0x000000000040e33b in runtime.gosched () at /home/xiemengjun/go/src/pkg/runtime/proc.c:927
|
||||
#1 0x0000000000403091 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
|
||||
at /home/xiemengjun/go/src/pkg/runtime/chan.c:327
|
||||
#2 0x000000000040316f in runtime.chanrecv2 (t=void, c=void)
|
||||
at /home/xiemengjun/go/src/pkg/runtime/chan.c:420
|
||||
#3 0x0000000000400d6f in main.main () at /home/xiemengjun/gdbfile.go:22
|
||||
#4 0x000000000040d0c7 in runtime.main () at /home/xiemengjun/go/src/pkg/runtime/proc.c:244
|
||||
#5 0x000000000040d16a in schedunlock () at /home/xiemengjun/go/src/pkg/runtime/proc.c:267
|
||||
#6 0x0000000000000000 in ?? ()
|
||||
|
||||
From the `goroutines` command, we can have a better picture of what Go's runtime system is doing internally; the calling sequence for each function is plainly displayed.
|
||||
|
||||
## Summary
|
||||
|
||||
In this section, we introduced some basic commands from the GDB debugger that you can use to debug your Go applications. These included the `run`, `print`, `info`, `set variable`, `continue`, `list` and `break` commands, among others. From the brief examples above, I hope that you will have a better understanding of how the debugging process works in Go using the GDB debugger. If you want to get more debugging tips, please refer to the GDB manual on its [official website](http://www.gnu.org/software/gdb/).
|
||||
|
||||
## Links
|
||||
|
||||
- [Directory](preface.md)
|
||||
- Previous section: [Error handling](11.1.md)
|
||||
- Next section: [Write test cases](11.3.md)
|
||||
|
||||
Reference in New Issue
Block a user