def "PID can be null"() {
        given:
        def daemonContext = new DefaultDaemonContext(null, null, null, null, null, null, null, false, NativeServicesMode.ENABLED, null)

        when:
        def pid = daemonContext.pid;

        then:
        noExceptionThrown()
        pid == null
    }

    def "PID unboxing should not happen in Status"() {
        given:

        <tr>
            <td>Hostname</td>
            <td>{{.Hostname}}</td>
        </tr>

        <tr>
            <td>Parent Process Id</td>
            <td>{{.Ppid}}</td>
        </tr>

        <tr>
            <td>Process Id</td>
            <td>{{.Pid}}</td>
        </tr>

        <tr>
            <td>Temporary Directory</td>
            <td>{{.TempDir}}</td>
        </tr>

        <tr>

// 'cert.pem' and 'key.pem' and will overwrite existing files.

package main

import (
	"crypto/ecdsa"
	"crypto/ed25519"
	"crypto/elliptic"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/pem"
	"flag"
	"log"
	"math/big"
	"net"
	"os"
	"strings"
	"time"
)

var (
	host       = flag.String("host", "", "Comma-separated hostnames and IPs to generate a certificate for")

            encoder.writeSmallInt(context.javaVersion.asInt());
            encoder.writeString(context.daemonRegistryDir.getPath());
            encoder.writeBoolean(context.pid != null);
            if (context.pid != null) {
                encoder.writeLong(context.pid);
            }
            encoder.writeBoolean(context.idleTimeout != null);
            if (context.idleTimeout != null) {

// The undergoing I/O system call can either complete or be
// interrupted by a note.
type asyncIO struct {
	res chan result

	// mu guards the pid field.
	mu sync.Mutex

	// pid holds the process id of
	// the process running the IO operation.
	pid int
}

// result is the return value of a Read or Write operation.
type result struct {
	n   int
	err error
}

*/

package oom

import (
	"os"

	"github.com/opencontainers/runc/libcontainer/cgroups"
	"testing"

	"github.com/stretchr/testify/assert"
)

// Converts a sequence of PID lists into a PID lister.
// The PID lister returns pidListSequence[i] on the ith call. If i >= length of pidListSequence
// then return the last element of pidListSequence (the sequence is considered to have) stabilized.

		In: `package main

import (
	"asn1"
	"crypto"
	"crypto/rsa"
	_ "crypto/sha1"
	"crypto/x509"
	"crypto/x509/pkix"
	"time"
)

var x = 1
`,
		Out: `package main

import (
	"crypto"
	"crypto/rsa"
	_ "crypto/sha1"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/asn1"
	"time"
)

var x = 1
`,
	},
	{
		Name: "import.15",

	l := p.local                              // load-consume
	if uintptr(pid) < s {
		return indexLocal(l, pid), pid
	}
	return p.pinSlow()
}

func (p *Pool) pinSlow() (*poolLocal, int) {
	// Retry under the mutex.
	// Can not lock the mutex while pinned.
	runtime_procUnpin()
	allPoolsMu.Lock()
	defer allPoolsMu.Unlock()
	pid := runtime_procPin()
	// poolCleanup won't be called while we are pinned.

    private final boolean largeFile;
    private int pid;
    private long byteOffset;
    private long lengthInBytes;


    /**
     * @param largeFile
     * 
     */
    public LockingAndXRange ( boolean largeFile ) {
        this.largeFile = largeFile;
    }


    /**
     * 
     * @return pid
     */
    public int getPid () {
        return this.pid;
    }


    /**
     * 

## 存档回调

实际的回调代码高度依赖于您自己的 API 应用。

并且可能每个应用都各不相同。

回调代码可能只有一两行，比如：

```Python
callback_url = "https://example.com/api/v1/invoices/events/"
requests.post(callback_url, json={"description": "Invoice paid", "paid": True})
```

但回调最重要的部分可能是，根据 API 要发送给回调请求体的数据等内容，确保您的 API 用户（外部开发者）正确地实现*外部 API*。

因此，我们下一步要做的就是添加代码，为从 API 接收回调的*外部 API*存档。

这部分文档在 `/docs` 下的 Swagger API 文档中显示，并且会告诉外部开发者如何构建*外部 API*。