func TestEmbeddedStructA5(t *testing.T) {
	testJsonFromStruct(t, A5{}, `{
  "swagger.A5": {
   "id": "swagger.A5",
   "required": [
    "d"
   ],
   "properties": {
    "d": {
     "$ref": "swagger.D"
    }
   }
  },
  "swagger.D": {
   "id": "swagger.D",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`)
}
clear && go test -v -test.run TestStructA5 ...swagger
package swagger
import (
	"net"
	"testing"
	"time"
)
type YesNo bool
func (y YesNo) MarshalJSON() ([]byte, error) {
	if y {
		return []byte("yes"), nil
	}
	return []byte("no"), nil
}
func TestRef_Issue190(t *testing.T) {
	type User struct {
		items []string
	}
	testJsonFromStruct(t, User{}, `{
  "swagger.User": {
   "id": "swagger.User",
   "required": [
    "items"
   ],
   "properties": {
    "items": {
     "type": "array",
     "items": {
      "type": "string"
     }
    }
   }
  }
 }`)
}
func TestCustomMarshaller_Issue96(t *testing.T) {
	type Vote struct {
		What YesNo
	}
	testJsonFromStruct(t, Vote{}, `{
  "swagger.Vote": {
   "id": "swagger.Vote",
   "required": [
    "What"
   ],
   "properties": {
    "What": {
     "type": "string"
    }
   }
  }
 }`)
}
func TestPrimitiveTypes(t *testing.T) {
	type Prims struct {
		f float64
		t time.Time
	}
	testJsonFromStruct(t, Prims{}, `{
  "swagger.Prims": {
   "id": "swagger.Prims",
   "required": [
    "f",
    "t"
   ],
   "properties": {
    "f": {
     "type": "number",
     "format": "double"
    },
    "t": {
     "type": "string",
     "format": "date-time"
    }
   }
  }
 }`)
}
func TestPrimitivePtrTypes(t *testing.T) {
	type Prims struct {
		f *float64
		t *time.Time
		b *bool
		s *string
		i *int
	}
	testJsonFromStruct(t, Prims{}, `{
  "swagger.Prims": {
   "id": "swagger.Prims",
   "required": [
    "f",
    "t",
    "b",
    "s",
    "i"
   ],
   "properties": {
    "b": {
     "type": "boolean"
    },
    "f": {
     "type": "number",
     "format": "double"
    },
    "i": {
     "type": "integer",
     "format": "int32"
    },
    "s": {
     "type": "string"
    },
    "t": {
     "type": "string",
     "format": "date-time"
    }
   }
  }
 }`)
}
func TestS1(t *testing.T) {
	type S1 struct {
		Id string
	}
	testJsonFromStruct(t, S1{}, `{
  "swagger.S1": {
   "id": "swagger.S1",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "string"
    }
   }
  }
 }`)
}
func TestS2(t *testing.T) {
	type S2 struct {
		Ids []string
	}
	testJsonFromStruct(t, S2{}, `{
  "swagger.S2": {
   "id": "swagger.S2",
   "required": [
    "Ids"
   ],
   "properties": {
    "Ids": {
     "type": "array",
     "items": {
      "type": "string"
     }
    }
   }
  }
 }`)
}
func TestS3(t *testing.T) {
	type NestedS3 struct {
		Id string
	}
	type S3 struct {
		Nested NestedS3
	}
	testJsonFromStruct(t, S3{}, `{
  "swagger.NestedS3": {
   "id": "swagger.NestedS3",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "string"
    }
   }
  },
  "swagger.S3": {
   "id": "swagger.S3",
   "required": [
    "Nested"
   ],
   "properties": {
    "Nested": {
     "$ref": "swagger.NestedS3"
    }
   }
  }
 }`)
}
type sample struct {
	id       string `swagger:"required"`  
	items    []item
	rootItem item `json:"root" description:"root desc"`
}
type item struct {
	itemName string `json:"name"`
}
func TestSampleToModelAsJson(t *testing.T) {
	testJsonFromStruct(t, sample{items: []item{}}, `{
  "swagger.item": {
   "id": "swagger.item",
   "required": [
    "name"
   ],
   "properties": {
    "name": {
     "type": "string"
    }
   }
  },
  "swagger.sample": {
   "id": "swagger.sample",
   "required": [
    "id",
    "items",
    "root"
   ],
   "properties": {
    "id": {
     "type": "string"
    },
    "items": {
     "type": "array",
     "items": {
      "$ref": "swagger.item"
     }
    },
    "root": {
     "$ref": "swagger.item",
     "description": "root desc"
    }
   }
  }
 }`)
}
func TestJsonTags(t *testing.T) {
	type X struct {
		A string
		B string `json:"-"`
		C int    `json:",string"`
		D int    `json:","`
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A",
    "C",
    "D"
   ],
   "properties": {
    "A": {
     "type": "string"
    },
    "C": {
     "type": "string"
    },
    "D": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestJsonTagOmitempty(t *testing.T) {
	type X struct {
		A int `json:",omitempty"`
		B int `json:"C,omitempty"`
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "properties": {
    "A": {
     "type": "integer",
     "format": "int32"
    },
    "C": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestJsonTagName(t *testing.T) {
	type X struct {
		A string `json:"B"`
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "type": "string"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestAnonymousStruct(t *testing.T) {
	type X struct {
		A struct {
			B int
		}
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A"
   ],
   "properties": {
    "A": {
     "$ref": "swagger.X.A"
    }
   }
  },
  "swagger.X.A": {
   "id": "swagger.X.A",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestAnonymousPtrStruct(t *testing.T) {
	type X struct {
		A *struct {
			B int
		}
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A"
   ],
   "properties": {
    "A": {
     "$ref": "swagger.X.A"
    }
   }
  },
  "swagger.X.A": {
   "id": "swagger.X.A",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestAnonymousArrayStruct(t *testing.T) {
	type X struct {
		A []struct {
			B int
		}
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A"
   ],
   "properties": {
    "A": {
     "type": "array",
     "items": {
      "$ref": "swagger.X.A"
     }
    }
   }
  },
  "swagger.X.A": {
   "id": "swagger.X.A",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestAnonymousPtrArrayStruct(t *testing.T) {
	type X struct {
		A *[]struct {
			B int
		}
	}
	expected := `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A"
   ],
   "properties": {
    "A": {
     "type": "array",
     "items": {
      "$ref": "swagger.X.A"
     }
    }
   }
  },
  "swagger.X.A": {
   "id": "swagger.X.A",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`
	testJsonFromStruct(t, X{}, expected)
}
func TestEmbeddedStruct_Issue98(t *testing.T) {
	type Y struct {
		A int
	}
	type X struct {
		Y
	}
	testJsonFromStruct(t, X{}, `{
  "swagger.X": {
   "id": "swagger.X",
   "required": [
    "A"
   ],
   "properties": {
    "A": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`)
}
type Dataset struct {
	Names []string
}
func TestIssue85(t *testing.T) {
	anon := struct{ Datasets []Dataset }{}
	testJsonFromStruct(t, anon, `{
  "struct { Datasets ||swagger.Dataset }": {
   "id": "struct { Datasets ||swagger.Dataset }",
   "required": [
    "Datasets"
   ],
   "properties": {
    "Datasets": {
     "type": "array",
     "items": {
      "$ref": "swagger.Dataset"
     }
    }
   }
  },
  "swagger.Dataset": {
   "id": "swagger.Dataset",
   "required": [
    "Names"
   ],
   "properties": {
    "Names": {
     "type": "array",
     "items": {
      "type": "string"
     }
    }
   }
  }
 }`)
}
type File struct {
	History     []File
	HistoryPtrs []*File
}
func TestRecursiveStructure(t *testing.T) {
	testJsonFromStruct(t, File{}, `{
  "swagger.File": {
   "id": "swagger.File",
   "required": [
    "History",
    "HistoryPtrs"
   ],
   "properties": {
    "History": {
     "type": "array",
     "items": {
      "$ref": "swagger.File"
     }
    },
    "HistoryPtrs": {
     "type": "array",
     "items": {
      "$ref": "swagger.File"
     }
    }
   }
  }
 }`)
}
type A1 struct {
	B struct {
		Id      int
		Comment string `json:"comment,omitempty"`
	}
}
func TestEmbeddedStructA1(t *testing.T) {
	testJsonFromStruct(t, A1{}, `{
  "swagger.A1": {
   "id": "swagger.A1",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "$ref": "swagger.A1.B"
    }
   }
  },
  "swagger.A1.B": {
   "id": "swagger.A1.B",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "integer",
     "format": "int32"
    },
    "comment": {
     "type": "string"
    }
   }
  }
 }`)
}
type A2 struct {
	C
}
type C struct {
	Id      int    `json:"B"`
	Comment string `json:"comment,omitempty"`
	Secure  bool   `json:"secure"`
}
func TestEmbeddedStructA2(t *testing.T) {
	testJsonFromStruct(t, A2{}, `{
  "swagger.A2": {
   "id": "swagger.A2",
   "required": [
    "B",
    "secure"
   ],
   "properties": {
    "B": {
     "type": "integer",
     "format": "int32"
    },
    "comment": {
     "type": "string"
    },
    "secure": {
     "type": "boolean"
    }
   }
  }
 }`)
}
type A3 struct {
	B D
}
type D struct {
	Id int
}
func TestStructA3(t *testing.T) {
	testJsonFromStruct(t, A3{}, `{
  "swagger.A3": {
   "id": "swagger.A3",
   "required": [
    "B"
   ],
   "properties": {
    "B": {
     "$ref": "swagger.D"
    }
   }
  },
  "swagger.D": {
   "id": "swagger.D",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`)
}
type A4 struct {
	D "json:,inline"
}
func TestEmbeddedStructA4(t *testing.T) {
	testJsonFromStruct(t, A4{}, `{
  "swagger.A4": {
   "id": "swagger.A4",
   "required": [
    "Id"
   ],
   "properties": {
    "Id": {
     "type": "integer",
     "format": "int32"
    }
   }
  }
 }`)
}
type A5 struct {
	D `json:"d"`
}