"strings"
	"text/scanner"

	"cmd/asm/internal/flags"
	"cmd/internal/objabi"
	"cmd/internal/src"
)

// Input is the main input: a stack of readers and some macro definitions.
// It also handles #include processing (by pushing onto the input stack)
// and parses and instantiates macro definitions.
type Input struct {
	Stack
	includes        []string
	beginningOfLine bool
	ifdefStack      []bool

Anis Eleuch <******@****.***> 1712232280 +0100

    assert response.json() == {
        "detail": [
            {
                "type": "bool_parsing",
                "loc": ["path", "item_id"],
                "msg": "Input should be a valid boolean, unable to interpret input",
                "input": "foobar",
            }
        ]
    }


def test_path_bool_True():
    response = client.get("/path/bool/True")
    assert response.status_code == 200

	testCase := []struct {
		name   string
		input  map[string]interface{}
		expect clause.Values
	}{
		{
			name: "Test convert string value",
			input: map[string]interface{}{
				"name": "my name",
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "name"}},
				Values:  [][]interface{}{{"my name"}},
			},
		},
		{
			name: "Test convert int value",
			input: map[string]interface{}{
				"age": 18,

)

func TestKVFields(t *testing.T) {
	tests := []struct {
		input          string
		keys           []string
		expectedFields map[string]struct{}
	}{
		// No keys present
		{
			input:          "",
			keys:           []string{"comment"},
			expectedFields: map[string]struct{}{},
		},
		// No keys requested for tokenizing
		{
			input:          `comment="Hi this is my comment ="`,
			keys:           []string{},

        try (Reader in = input) {
            return read(in, isStrict(options), getSource(options));
        }
    }

    @Override
    public Model read(InputStream input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (XmlStreamReader in = ReaderFactory.newXmlReader(input)) {

                "type": "missing",
                "loc": ["body", "file"],
                "msg": "Field required",
                "input": None,
            },
            {
                "type": "missing",
                "loc": ["body", "fileb"],
                "msg": "Field required",
                "input": None,
            },
            {
                "type": "missing",
                "loc": ["body", "token"],

	readCloser   io.ReadCloser          // raw input
	buf          *bufio.Reader          // input to the splitter
	columnNames  []string               // names of columns
	nameIndexMap map[string]int64       // name to column index
	current      [][]string             // current block of results to be returned
	recordsRead  int                    // number of records read in current slice
	input        chan *queueItem        // input for workers

		}
		return r, nil
	}
}

// EvalFrom evaluates the From clause on the input record. It only
// applies to JSON input data format (currently).
func (e *SelectStatement) EvalFrom(format string, input Record) ([]*Record, error) {
	if !e.selectAST.From.HasKeypath() {
		return []*Record{&input}, nil
	}
	_, rawVal := input.Raw()

	if format != "json" {
		return nil, errDataSource(errors.New("path not supported"))

    assert response.json() == {
        "detail": [
            {
                "type": "float_parsing",
                "loc": ["body", "price"],
                "msg": "Input should be a valid number, unable to parse string as a number",
                "input": "twenty",
            }
        ]
    }


def test_post_with_no_data(client: TestClient):
    response = client.post("/items/", json={})