error#1fbadfee code:int32 message:string = Error;

sendPM#3faceff text:string habrauser:string = Error;

func TestDefinition(t *testing.T) {
  for _, tt := range []struct {
    Case       string
    Input      string
    String     string
    Definition Definition
  }{
    {
      Case:  "inputPhoneCall",
      Input: "inputPhoneCall#1e36fded id:long access_hash:long = InputPhoneCall",
      Definition: Definition{
        ID:   0x1e36fded,
        Name: "inputPhoneCall",
        Params: []Parameter{
          {
            Name: "id",
            Type: bareLong,
          },
          {
            Name: "access_hash",
            Type: bareLong,
          },
        },
        Type: Type{Name: "InputPhoneCall"},
      },
    },
    // ...
  } {
    t.Run(tt.Case, func(t *testing.T) {
      var d Definition
      if err := d.Parse(tt.Input); err != nil {
        t.Fatal(err)
      }
      require.Equal(t, tt.Definition, d)
    })
  }
}

t.Run("Error", func(t *testing.T) {
    for _, invalid := range []string{
      "=0",
      "0 :{.0?InputFi00=0",
    } {
      t.Run(invalid, func(t *testing.T) {
        var d Definition
        if err := d.Parse(invalid); err == nil {
          t.Error("should error")
        }
      })
    }
  })

func TestParseSample(t *testing.T) {
  data, err := ioutil.ReadFile(filepath.Join("_testdata", "Sample.tl"))
  if err != nil {
    t.Fatal(err)
  }
  schema, err := Parse(bytes.NewReader(data))
  if err != nil {
    t.Fatal(err)
  }
  // ...
}

func TestParser(t *testing.T) {
  for _, v := range []string{
    "td_api.tl",
    "telegram_api.tl",
    "telegram_api_header.tl",
    "layer.tl",
  } {
    t.Run(v, func(t *testing.T) {
      data, err := ioutil.ReadFile(filepath.Join("_testdata", v))
      if err != nil {
        t.Fatal(err)
      }
      schema, err := Parse(bytes.NewReader(data))
      if err != nil {
        t.Fatal(err)
      }
      t.Run("JSON", func(t *testing.T) {
        g := goldie.New(t,
          goldie.WithFixtureDir(filepath.Join("_golden", "parser", "json")),
          goldie.WithDiffEngine(goldie.ColoredDiff),
          goldie.WithNameSuffix(".json"),
        )
        g.AssertJson(t, v, schema)
      })
    })
  }
}

// Annotation represents an annotation comment, like //@name value.
type Annotation struct {
  Name  string `json:"name"`
  Value string `json:"value"`
}
func (a Annotation) String() string {
  var b strings.Builder
  b.WriteString("//")
  b.WriteRune('@')
  b.WriteString(a.Name)
  b.WriteRune(' ')
  b.WriteString(a.Value)
  return b.String()
}

// +build fuzz
package tl
import "fmt"
func FuzzDefinition(data []byte) int {
  var d Definition
  if err := d.Parse(string(data)); err != nil {
    return 0
  }
  var other Definition
  if err := other.Parse(d.String()); err != nil {
    fmt.Printf("input: %s\n", string(data))
    fmt.Printf("parsed: %#v\n", d)
    panic(err)
  }
  return 1
}