import org.gradle.test.fixtures.file.TestFile

class IdeaFixtures {
    static parseFile(TestFile file) {
        file.assertIsFile()
        new XmlSlurper().parse(file)
    }

    static IdeaProjectFixture parseIpr(TestFile projectFile) {
        return new IdeaProjectFixture(projectFile, parseFile(projectFile))
    }

    static IdeaModuleFixture parseIml(TestFile moduleFile) {

    String workspaceTask = "idea"
    String libraryPluginId = "java-library"

    @Override
    IdeaProjectFixture workspace(TestFile workspaceDir, String ideWorkspaceName) {
        return IdeaFixtures.parseIpr(workspaceDir.file(ideWorkspaceName + ".ipr"))
    }

    @Override
    IdeaModuleFixture project(TestFile projectDir, String ideProjectName) {
        return IdeaFixtures.parseIml(projectDir.file(ideProjectName + ".iml"))

	}
	return eventC
}

var fakeCmdArgs = &skel.CmdArgs{
	Netns:       "someNetNS",
	IfName:      "ethBro",
	ContainerID: "bbb-eee-www",
}

var (
	fakeIP                 = net.ParseIP("99.9.9.9")
	fakeGW                 = net.ParseIP("88.9.9.9")
	fakeIDX                = 0
	fakePrevResultIPConfig = cniv1.IPConfig{
		Interface: &fakeIDX,
		Address: net.IPNet{
			IP: fakeIP,
		},
		Gateway: fakeGW,
	}
)

			continue
		}
		mifc = &ifc
		break
	}

	if mifc == nil {
		t.Skipf("no multicast interfaces found")
	}

	c1, err := ListenMulticastUDP("udp4", mifc, &UDPAddr{IP: ParseIP("224.0.0.254")})
	if err != nil {
		t.Fatalf("multicast not working on %s: %v", runtime.GOOS, err)
	}
	c1addr := c1.LocalAddr().(*UDPAddr)
	if err != nil {
		t.Fatal(err)
	}
	defer c1.Close()

	"os"
)

func ExampleFunc() {
	fs := flag.NewFlagSet("ExampleFunc", flag.ContinueOnError)
	fs.SetOutput(os.Stdout)
	var ip net.IP
	fs.Func("ip", "`IP address` to parse", func(s string) error {
		ip = net.ParseIP(s)
		if ip == nil {
			return errors.New("could not parse IP")
		}
		return nil
	})
	fs.Parse([]string{"-ip", "127.0.0.1"})
	fmt.Printf("{ip: %v, loopback: %t}\n\n", ip, ip.IsLoopback())

func sortIPs(ipList []string) []string {
	if len(ipList) == 1 {
		return ipList
	}

	var ipV4s []net.IP
	var nonIPs []string
	for _, ip := range ipList {
		nip := net.ParseIP(ip)
		if nip != nil {
			ipV4s = append(ipV4s, nip)
		} else {
			nonIPs = append(nonIPs, ip)
		}
	}

	sort.Slice(ipV4s, func(i, j int) bool {
		// This case is needed when all ips in the list

Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 "Créé".

Pour y parvenir, importez `JSONResponse` et renvoyez-y directement votre contenu, en définissant le `status_code` que vous souhaitez :

```Python hl_lines="4 25"
{!../../../docs_src/additional_status_codes/tutorial001.py!}
```

    def parsesCombinedShortOptions() {
        parser.option('a')
        parser.option('b')

        expect:
        def result = parser.parse(['-ab'])
        result.hasOption('a')
        result.hasOption('b')
    }

    def parsesLongOption() {
        parser.option('long-option-a')
        parser.option('long-option-b')

        expect:
        def result = parser.parse(['--long-option-a'])

    internal
    inline fun <T> paren(crossinline parser: Parser<T>): Parser<T> =
        token(LPAR) * parser * token(RPAR)


    internal
    inline fun <T> bracket(crossinline parser: Parser<T>): Parser<T> =
        token(LBRACKET) * parser * token(RBRACKET)


    internal
    inline fun <T> brace(crossinline parser: Parser<T>): Parser<T> =
        token(LBRACE) * parser * token(RBRACE)


    internal

				svcAllocator, ok := allocator.(*ipallocator.MetaAllocator)
				if ok {
					err = svcAllocator.AllocateService(service, parsedIP)
				} else {
					err = allocator.Allocate(parsedIP)
				}
			} else {
				err = allocator.Allocate(parsedIP)
			}
			if err != nil {