def test_openapi_schema_sub():
    response = client.get("/subapi/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema_sub


def test_sub():
    response = client.get("/subapi/sub")
    assert response.status_code == 200, response.text

        public void setNotUsed(boolean notUsed) {
            throw new RuntimeException("Not used");
        }

        TestEnum anEnum

        @Option(option = "someEnum", description = "some enum value.")
        public void setEnum(TestEnum anEnum) {
            this.anEnum = anEnum;
        }

        @TaskAction
        public void dummy() {}
    }

	"os"
	"path/filepath"
	"testing"
)

const asmData = `
GLOBL zeros<>(SB),8,$64
TEXT ·testASM(SB),4,$0
VMOVUPS zeros<>(SB), %s // PC relative relocation is off by 1, for Y8-Y15, Z8-15 and Z24-Z31
RET
`

const goData = `
package main

func testASM()

func main() {
	testASM()
}
`

func objdumpOutput(t *testing.T, mname, source string) []byte {
	tmpdir, err := os.MkdirTemp("", mname)

		t.Errorf("got %q; want %q", got, want)
	}
}

func TestCompose(t *testing.T) {
	var buf strings.Builder
	var testNum int

	connectStart := func(b byte) func(network, addr string) {
		return func(network, addr string) {
			if addr != "addr" {
				t.Errorf(`%d. args for %q case = %q, %q; want addr of "addr"`, testNum, b, network, addr)
			}
			buf.WriteByte(b)
		}
	}

	tests := [...]struct {
		trace, old *ClientTrace

    }

    def adaptsEnum() {
        TestProtocolModel protocolModel = Mock()
        _ * protocolModel.getTestEnum() >> TestEnum.FIRST

        expect:
        TestModel model = adapter.adapt(TestModel.class, protocolModel)
        model.testEnum == TestEnum.FIRST
    }

    def adaptsStringToEnum() {
        TestProtocolModel protocolModel = Mock()
        _ * protocolModel.getTestEnum() >> "SECOND"

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build test_run

// Run the game of life in C using Go for parallelization.

package main

import (
	"flag"
	"fmt"

	"cgolife"
)

const MAXDIM = 100

var dim = flag.Int("dim", 16, "board dimensions")
var gen = flag.Int("gen", 10, "generations")

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build test_run

package main

import "cgostdio/stdio"

func main() {
	stdio.Stdout.WriteString(stdio.Greeting + "\n")

        @Option(description = "Descr enumListValue")
        final ListProperty<TestEnum> enumListValue

        @Option(description = "Descr enumSetValue")
        final SetProperty<TestEnum> enumSetValue

        @Option(description = "Descr enumValue")
        final Property<TestEnum> enumValue

        @Option(description = "Descr integerValue")
        final Property<Integer> integerValue

func TestCheckConst(t *testing.T)            { testCheckConst(t) }
func TestConst(t *testing.T)                 { testConst(t) }
func TestCthread(t *testing.T)               { testCthread(t) }
func TestEnum(t *testing.T)                  { testEnum(t) }
func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
func TestErrno(t *testing.T)                 { testErrno(t) }

	}
	a.Add(mc, map[int]int{16: 32})
	want := map[int]int{1: 2, 2: 4, 4: 8, 8: 16, 16: 32}
	if !a.Equal(mc, want) {
		panic(fmt.Sprintf("a.Add result = %v, want %v", mc, want))
	}
}

func TestSub() {
	mc := a.Copy(m1)
	a.Sub(mc, mc)
	if len(mc) > 0 {
		panic(fmt.Sprintf("a.Sub(%v, %v) = %v, want empty map", m1, m1, mc))
	}
	mc = a.Copy(m1)
	a.Sub(mc, map[int]int{1: 0})