[
	uuid(12345778-1234-abcd-ef00-0123456789ab),
	version(0.0)
]
interface lsarpc
{
	import "../rpc.idl";

	typedef struct {
		uint32_t length;
		uint16_t impersonation_level;
		uint8_t context_mode;
		uint8_t effective_only;
	} LsarQosInfo;

	typedef struct {
		uint32_t length;
		uint8_t *root_directory;
		unicode_string *object_name;
		uint32_t attributes;
		uint32_t security_descriptor;

[
	uuid(12345778-1234-abcd-ef00-0123456789ab),
	version(0.0)
]
interface lsarpc
{
	import "../rpc.idl";

	typedef struct {
		uint32_t length;
		uint16_t impersonation_level;
		uint8_t context_mode;
		uint8_t effective_only;
	} LsarQosInfo;

	typedef struct {
		uint32_t length;
		uint8_t *root_directory;
		unicode_string *object_name;
		uint32_t attributes;
		uint32_t security_descriptor;

# Usage

```go
package main

import (
	"fmt"

	"github.com/smallnest/ringbuffer"
)

func main() {
	rb := ringbuffer.New(1024)

	// write
	rb.Write([]byte("abcd"))
	fmt.Println(rb.Length())
	fmt.Println(rb.Free())

	// read
	buf := make([]byte, 4)
	rb.Read(buf)
	fmt.Println(string(buf))
}
```

		},
		{
			name:         "ipv6 isLoopback true",
			expr:         `ip("::1").isLoopback()`,
			expectResult: trueVal,
		},
		{
			name:         "ipv6 isLoopback false",
			expr:         `ip("2001:db8::abcd").isLoopback()`,
			expectResult: falseVal,
		},
		{
			name:         "ipv6 isLinkLocalMulticast true",
			expr:         `ip("ff02::1").isLinkLocalMulticast()`,
			expectResult: trueVal,
		},
		{

    val response = newResponse(responseBody("abcdef"))
    val p1 = response.peekBody(4)
    val p2 = response.peekBody(2)
    assertThat(response.body.string()).isEqualTo("abcdef")
    assertThat(p1.string()).isEqualTo("abcd")
    assertThat(p2.string()).isEqualTo("ab")
  }

  @Test fun negativeStatusCodeThrowsIllegalStateException() {
    assertFailsWith<IllegalStateException> {
      newResponse(responseBody("set status code -1"), -1)

            assert partialCacheFile.name.startsWith(hashCode)
            assert partialCacheFile.name.endsWith(BuildCacheTempFileStore.PARTIAL_FILE_SUFFIX)

            output << "abcd"
            throw new RuntimeException("Simulated write error")
        }

        then:
        def ex = thrown RuntimeException
        ex.message == "Simulated write error"

		}
	}
}

var onePassTests = []struct {
	re        string
	isOnePass bool
}{
	{`^(?:a|(?:a*))$`, false},
	{`^(?:(a)|(?:a*))$`, false},
	{`^(?:(?:(?:.(?:$))?))$`, true},
	{`^abcd$`, true},
	{`^(?:(?:a{0,})*?)$`, false},
	{`^(?:(?:a+)*)$`, true},
	{`^(?:(?:a|(?:aa)))$`, true},
	{`^(?:[^\s\S])$`, true},
	{`^(?:(?:a{3,4}){0,})$`, false},
	{`^(?:(?:(?:a*)+))$`, true},
	{`^[a-c]+$`, true},

        !step5.matches("other")

        and:
        def step6 = PatternStepFactory.getStep("*bc*?", true);
        step6 instanceof RegExpPatternStep
        step6.matches("bcd")
        step6.matches("abcd")
        step6.matches("123abc1")
        !step6.matches("bc")
        !step6.matches("BC")
        !step6.matches("ABC")
        !step6.matches("other")

        and:

		ok, msg := cmpReaders(r1, r2)
		if !(ok && msg == "") {
			t.Fatalf("unexpected")
		}
	}

	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abcd"))
		ok, _ := cmpReaders(r1, r2)
		if ok {
			t.Fatalf("unexpected")
		}
	}

}

// CgroupName is the abstract name of a cgroup prior to any driver specific conversion.
// It is specified as a list of strings from its individual components, such as:
// {"kubepods", "burstable", "pod1234-abcd-5678-efgh"}
type CgroupName []string

// CgroupConfig holds the cgroup configuration information.
// This is common object which is used to specify
// cgroup information to both systemd and raw cgroup fs