wrong-rules-conjunctions-tests.jst

JSIGHT 0.3

INFO
  Description
    Delete types one by one and check that every type raises an
    error in a right line.

  Version 1.0

# Object

TYPE @testWrongRules1
{
  "object": {} /* {type: "object",
                        enum: ["white", "black"]                            
                }*/
}

TYPE @testWrongRules2
{
  "object": {} /* {type: "object",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules3
{
  "object": {} /* {type: "object",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules4
{
  "object": {} /* {type: "object",
                        regex: "^[A-Za-z]+$",
                }*/
}

TYPE @testWrongRules5
{
  "object": {} /* {type: "object",
                        maxLength: 100
                }*/
}

TYPE @testWrongRules6
{
  "object": {} /* {type: "object",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules7
{
  "object": {} /* {type: "object",
                        precision: 2,
                }*/
}

TYPE @testWrongRules8
{
  "object": {} /* {type: "object",
                        max: 1,
                }*/
}

TYPE @testWrongRules9
{
  "object": {} /* {type: "object",
                        min: 0,
                }*/
}

TYPE @testWrongRules10
{
  "object": {} /* {type: "object",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules11
{
  "object": {} /* {type: "object",
                        const: true
                }*/
}

# array
TYPE @testWrongRules12
{
  "array" : [   /* {type: "array",
                        const: true,
                }*/
    "item"
  ]
}

TYPE @testWrongRules13
{
  "array" : [   /* {type: "array",
                        min: 0,
                }*/
    "item"
  ]
}

TYPE @testWrongRules14
{
  "array" : [   /* {type: "array",
                        max: 1,
                }*/
    "item"
  ]
}

TYPE @testWrongRules15
{
  "array" : [   /* {type: "array",
                        exclusiveMinimum: true,
                }*/
    "item"
  ]
}

TYPE @testWrongRules16
{
  "array" : [   /* {type: "array",
                        exclusiveMaximum: true,
                }*/
    "item"
  ]
}

TYPE @testWrongRules17
{
  "array" : [   /* {type: "array",
                        precision: 2,
                }*/
    "item"
  ]
}

TYPE @testWrongRules18
{
  "array" : [   /* {type: "array",
                        minLength: 0, 
                }*/
    "item"
  ]
}

TYPE @testWrongRules19
{
  "array" : [   /* {type: "array",
                        maxLength: 100, 
                }*/
    "item"
  ]
}

TYPE @testWrongRules20
{
  "array" : [   /* {type: "array",
                        regex: "^[A-Za-z]+$",
                }*/
    "item"
  ]
}

TYPE @testWrongRules21
{
  "array" : [   /* {type: "array",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
    "item"
  ]
}

TYPE @testWrongRules22
{
  "array" : [   /* {type: "array",
                        additionalProperties: true, 
                }*/
    "item"
  ]
}

TYPE @testWrongRules23
{
  "array" : [   /* {type: "array",
                        allOf: "@cat",
                }*/
    "item"
  ]
}

TYPE @testWrongRules24
{
  "array" : [   /* {type: "array",
                        enum: ["white", "black"]                            
                }*/
    "item"
  ]
}

# integer

TYPE @testWrongRules25
{
  "integer": 1 /* {type: "integer",
                        precision: 2,
                }*/
}

TYPE @testWrongRules26
{
  "integer": 1 /* {type: "integer",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules27
{
  "integer": 1 /* {type: "integer",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules28
{
  "integer": 1 /* {type: "integer",
                        regex: "^[A-Za-z]+$",
                }*/
}

TYPE @testWrongRules29
{
  "integer": 1 /* {type: "integer",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules30
{
  "integer": 1 /* {type: "integer",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules31
{
  "integer": 1 /* {type: "integer",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules32
{
  "integer": 1 /* {type: "integer",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules33
{
  "integer": 1 /* {type: "integer",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules34
{
  "integer": 1 /* {type: "integer",
                        enum: ["white", "black"]                            
                }*/
}

# float

TYPE @testWrongRules35
{
  "float": 1.2 /* {type: "float",
                        precision: 1
                  }*/
}

TYPE @testWrongRules36
{
  "float": 1.2 /* {type: "float",
                        minLength: 0
                  }*/
}

TYPE @testWrongRules37
{
  "float": 1.2 /* {type: "float",
                        maxLength: 100
                  }*/
}

TYPE @testWrongRules38
{
  "float": 1.2 /* {type: "float",
                        regex: "^[A-Za-z]+$"
                  }*/
}

TYPE @testWrongRules39
{
  "float": 1.2 /* {type: "float",
                        minItems: 0
                  }*/
}

TYPE @testWrongRules40
{
  "float": 1.2 /* {type: "float",
                        maxItems: 10
                  }*/
}

TYPE @testWrongRules41
{
  "float": 1.2 /* {type: "float",
                        or: [{type: "string"}, {type: "float"}]
                  }*/
}

TYPE @testWrongRules42
{
  "float": 1.2 /* {type: "float",
                        additionalProperties: true
                  }*/
}

TYPE @testWrongRules43
{
  "float": 1.2 /* {type: "float",
                        allOf: "@cat"
                  }*/
}

TYPE @testWrongRules44
{
  "float": 1.2 /* {type: "float",
                        enum: [1.2, 1.3]                            
                  }*/
}

# decimal

TYPE @testWrongRules45
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules46
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules47
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        regex: "^[A-Za-z]+$",
                }*/
}

TYPE @testWrongRules48
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        minItems: 0,
                }*/
}

TYPE @testWrongRules49
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules50
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules51
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules52
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules53
{
  "decimal": 1.23 /* {type: "decimal", precision: 2,
                        enum: ["white", "black"]                            
                }*/
}

# boolean

TYPE @testWrongRules54
{
  "boolean": true /* {type: "boolean",
                        min: 0,
                }*/
}

TYPE @testWrongRules55
{
  "boolean": true /* {type: "boolean",
                        max: 1,
                }*/
}

TYPE @testWrongRules56
{
  "boolean": true /* {type: "boolean",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules57
{
  "boolean": true /* {type: "boolean",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules58
{
  "boolean": true /* {type: "boolean",
                        precision: 2,
                }*/
}

TYPE @testWrongRules59
{
  "boolean": true /* {type: "boolean",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules60
{
  "boolean": true /* {type: "boolean",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules61
{
  "boolean": true /* {type: "boolean",
                        regex: "^[A-Za-z]+$",
                }*/
}

TYPE @testWrongRules62
{
  "boolean": true /* {type: "boolean",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules63
{
  "boolean": true /* {type: "boolean",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules64
{
  "boolean": true /* {type: "boolean",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules65
{
  "boolean": true /* {type: "boolean",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules66
{
  "boolean": true /* {type: "boolean",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules67
{
  "boolean": true /* {type: "boolean",
                        enum: ["white", "black"]                            
                }*/
}

# string

TYPE @testWrongRules68
{
  "string": "value" /* {type: "string",
                        min: 0,
                }*/
}

TYPE @testWrongRules69
{
  "string": "value" /* {type: "string",
                        max: 1,
                }*/
}

TYPE @testWrongRules70
{
  "string": "value" /* {type: "string",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules71
{
  "string": "value" /* {type: "string",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules72
{
  "string": "value" /* {type: "string",
                        precision: 2,
                }*/
}

TYPE @testWrongRules73
{
  "string": "value" /* {type: "string",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules74
{
  "string": "value" /* {type: "string",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules75
{
  "string": "value" /* {type: "string",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules76
{
  "string": "value" /* {type: "string",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules77
{
  "string": "value" /* {type: "string",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules78
{
  "string": "value" /* {type: "string",
                        enum: ["white", "black"]                            
                }*/
}

# email

TYPE @testWrongRules79
{
  "email": "t@t.com" /* {type: "email",
                        min: 0,
                }*/
}

TYPE @testWrongRules80
{
  "email": "t@t.com" /* {type: "email",
                        max: 1,
                }*/
}

TYPE @testWrongRules81
{
  "email": "t@t.com" /* {type: "email",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules82
{
  "email": "t@t.com" /* {type: "email",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules83
{
  "email": "t@t.com" /* {type: "email",
                        precision: 2,
                }*/
}

TYPE @testWrongRules84
{
  "email": "t@t.com" /* {type: "email",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules85
{
  "email": "t@t.com" /* {type: "email",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules86
{
  "email": "t@t.com" /* {type: "email",
                        regex: ".*",
                }*/
}

TYPE @testWrongRules87
{
  "email": "t@t.com" /* {type: "email",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules88
{
  "email": "t@t.com" /* {type: "email",
                        maxItems: 10,
                }*/
}

# uri

TYPE @testWrongRules89
{
  "uri": "http://t.com" /* {type: "uri",
                        min: 0,
                }*/
}

TYPE @testWrongRules90
{
  "uri": "http://t.com" /* {type: "uri",
                        max: 1,
                }*/
}

TYPE @testWrongRules91
{
  "uri": "http://t.com" /* {type: "uri",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules92
{
  "uri": "http://t.com" /* {type: "uri",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules93
{
  "uri": "http://t.com" /* {type: "uri",
                        precision: 2,
                }*/
}

TYPE @testWrongRules94
{
  "uri": "http://t.com" /* {type: "uri",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules95
{
  "uri": "http://t.com" /* {type: "uri",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules96
{
  "uri": "http://t.com" /* {type: "uri",
                        regex: ".*",
                }*/
}

TYPE @testWrongRules97
{
  "uri": "http://t.com" /* {type: "uri",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules98
{
  "uri": "http://t.com" /* {type: "uri",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules99
{
  "uri": "http://t.com" /* {type: "uri",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules100
{
  "uri": "http://t.com" /* {type: "uri",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules101
{
  "uri": "http://t.com" /* {type: "uri",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules102
{
  "uri": "http://t.com" /* {type: "uri",
                        enum: ["white", "black"]                            
                }*/
}

# date

TYPE @testWrongRules103
{
  "date": "2021-12-16" /* {type: "date",
                        min: 0,
                }*/
}

TYPE @testWrongRules104
{
  "date": "2021-12-16" /* {type: "date",
                        max: 1,
                }*/
}

TYPE @testWrongRules105
{
  "date": "2021-12-16" /* {type: "date",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules106
{
  "date": "2021-12-16" /* {type: "date",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules107
{
  "date": "2021-12-16" /* {type: "date",
                        precision: 2,
                }*/
}

TYPE @testWrongRules108
{
  "date": "2021-12-16" /* {type: "date",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules109
{
  "date": "2021-12-16" /* {type: "date",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules110
{
  "date": "2021-12-16" /* {type: "date",
                        regex: ".*",
                }*/
}

TYPE @testWrongRules111
{
  "date": "2021-12-16" /* {type: "date",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules112
{
  "date": "2021-12-16" /* {type: "date",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules113
{
  "date": "2021-12-16" /* {type: "date",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules114
{
  "date": "2021-12-16" /* {type: "date",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules115
{
  "date": "2021-12-16" /* {type: "date",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules116
{
  "date": "2021-12-16" /* {type: "date",
                        enum: ["white", "black"]                            
                }*/
}

# datetime

TYPE @testWrongRules117
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        min: 0,
                          }*/
}

TYPE @testWrongRules118
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        max: 1,
                          }*/
}

TYPE @testWrongRules119
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        exclusiveMinimum: true,
                          }*/
}

TYPE @testWrongRules120
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        exclusiveMaximum: true,
                          }*/
}

TYPE @testWrongRules121
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        precision: 2,
                          }*/
}

TYPE @testWrongRules122
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        minLength: 0, 
                          }*/
}

TYPE @testWrongRules123
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        maxLength: 100, 
                          }*/
}

TYPE @testWrongRules124
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        regex: ".*",
                          }*/
}

TYPE @testWrongRules125
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        minItems: 0,
                          }*/
}

TYPE @testWrongRules126
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        maxItems: 10,
                          }*/
}

TYPE @testWrongRules127
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        or: [{type: "string"}, {type: "integer"}],
                          }*/
}

TYPE @testWrongRules128
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        additionalProperties: true, 
                          }*/
}

TYPE @testWrongRules129
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        allOf: "@cat",
                          }*/
}

TYPE @testWrongRules130
{
  "datetime": "2006-01-02T15:04:05+07:00" /* {type: "datetime",
                        enum: ["white", "black"]                            
                          }*/
}

# uuid

TYPE @testWrongRules131
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        min: 0,
                          }*/
}

TYPE @testWrongRules132
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        max: 1,
                          }*/
}

TYPE @testWrongRules133
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        exclusiveMinimum: true,
                          }*/
}

TYPE @testWrongRules134
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        exclusiveMaximum: true,
                          }*/
}

TYPE @testWrongRules135
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        precision: 2,
                          }*/
}

TYPE @testWrongRules136
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        minLength: 0, 
                          }*/
}

TYPE @testWrongRules137
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        maxLength: 100, 
                          }*/
}

TYPE @testWrongRules138
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        regex: ".*",
                          }*/
}

TYPE @testWrongRules139
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        minItems: 0,
                          }*/
}

TYPE @testWrongRules140
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        maxItems: 10,
                          }*/
}

TYPE @testWrongRules141
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        or: [{type: "string"}, {type: "integer"}],
                          }*/
}

TYPE @testWrongRules142
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        additionalProperties: true, 
                          }*/
}

TYPE @testWrongRules143
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        allOf: "@cat",
                          }*/
}

TYPE @testWrongRules144
{
  "uuid": "550e8400-e29b-41d4-a716-446655440000" /* {type: "uuid",
                        enum: ["white", "black"]                            
                          }*/
}

# enum

TYPE @testWrongRules145
{
  "enum": "white" /* {enum: ["white", "black"],
                        min: 0,
                }*/
}

TYPE @testWrongRules146
{
  "enum": "white" /* {enum: ["white", "black"],
                        max: 1,
                }*/
}

TYPE @testWrongRules147
{
  "enum": "white" /* {enum: ["white", "black"],
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules148
{
  "enum": "white" /* {enum: ["white", "black"],
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules149
{
  "enum": "white" /* {enum: ["white", "black"],
                        precision: 2,
                }*/
}

TYPE @testWrongRules150
{
  "enum": "white" /* {enum: ["white", "black"],
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules151
{
  "enum": "white" /* {enum: ["white", "black"],
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules152
{
  "enum": "white" /* {enum: ["white", "black"],
                        regex: ".*",
                }*/
}

TYPE @testWrongRules153
{
  "enum": "white" /* {enum: ["white", "black"],
                        minItems: 0,
                }*/
}

TYPE @testWrongRules154
{
  "enum": "white" /* {enum: ["white", "black"],
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules155
{
  "enum": "white" /* {enum: ["white", "black"],
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules156
{
  "enum": "white" /* {enum: ["white", "black"],
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules157
{
  "enum": "white" /* {enum: ["white", "black"],
                        allOf: "@cat",
                }*/
}

# mixed

TYPE @testWrongRules158
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        const: true,
                }*/
}

TYPE @testWrongRules159
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        min: 0,
                }*/
}

TYPE @testWrongRules160
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        max: 1,
                }*/
}

TYPE @testWrongRules161
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules162
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules163
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        precision: 2,
                }*/
}

TYPE @testWrongRules164
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules165
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules166
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        regex: ".*",
                }*/
}

TYPE @testWrongRules167
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        minItems: 0,
                }*/
}

TYPE @testWrongRules168
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules169
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules170
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules171
{
  "mixed": "abc" /* {or: [{type: "string"}, {type: "integer"}],
                        enum: ["white", "black"]                            
                }*/
}

# any

TYPE @testWrongRules172
{
  "any": 456 /* {type: "any",
                        min: 0,
                }*/
}

TYPE @testWrongRules173
{
  "any": 456 /* {type: "any",
                        max: 1,
                }*/
}

TYPE @testWrongRules174
{
  "any": 456 /* {type: "any",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules175
{
  "any": 456 /* {type: "any",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules176
{
  "any": 456 /* {type: "any",
                        precision: 2,
                }*/
}

TYPE @testWrongRules177
{
  "any": 456 /* {type: "any",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules178
{
  "any": 456 /* {type: "any",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules179
{
  "any": 456 /* {type: "any",
                        regex: ".*",
                }*/
}

TYPE @testWrongRules180
{
  "any": 456 /* {type: "any",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules181
{
  "any": 456 /* {type: "any",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules182
{
  "any": 456 /* {type: "any",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules183
{
  "any": 456 /* {type: "any",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules184
{
  "any": 456 /* {type: "any",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules185
{
  "any": 456 /* {type: "any",
                        enum: ["white", "black"]                            
                }*/
}

# null

TYPE @testWrongRules186
{
  "null": null /* {type: "null",
                        min: 0,
              }*/
}

TYPE @testWrongRules187
{
  "null": null /* {type: "null",
                        max: 1,
              }*/
}

TYPE @testWrongRules188
{
  "null": null /* {type: "null",
                        exclusiveMinimum: true,
              }*/
}

TYPE @testWrongRules189
{
  "null": null /* {type: "null",
                        exclusiveMaximum: true,
              }*/
}

TYPE @testWrongRules190
{
  "null": null /* {type: "null",
                        precision: 2,
              }*/
}

TYPE @testWrongRules191
{
  "null": null /* {type: "null",
                        minLength: 0, 
              }*/
}

TYPE @testWrongRules192
{
  "null": null /* {type: "null",
                        maxLength: 100, 
              }*/
}

TYPE @testWrongRules193
{
  "null": null /* {type: "null",
                        regex: ".*",
              }*/
}

TYPE @testWrongRules194
{
  "null": null /* {type: "null",
                        minItems: 0,
              }*/
}

TYPE @testWrongRules195
{
  "null": null /* {type: "null",
                        maxItems: 10,
              }*/
}

TYPE @testWrongRules196
{
  "null": null /* {type: "null",
                        or: [{type: "string"}, {type: "integer"}],
              }*/
}

TYPE @testWrongRules197
{
  "null": null /* {type: "null",
                        additionalProperties: true, 
              }*/
}

TYPE @testWrongRules198
{
  "null": null /* {type: "null",
                        allOf: "@cat",
              }*/
}

TYPE @testWrongRules199
{
  "null": null /* {type: "null",
                        enum: ["white", "black"]                            
              }*/
}

# user type reference

TYPE @testWrongRules200
{
  "userType1": @cat  /* {
                        type: "@cat",
                }*/
}

TYPE @testWrongRules201
{
  "userType1": @cat  /* {
                        min: 0,
                }*/
}

TYPE @testWrongRules202
{
  "userType1": @cat  /* {
                        max: 1,
                }*/
}

TYPE @testWrongRules203
{
  "userType1": @cat  /* {
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules204
{
  "userType1": @cat  /* {
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules205
{
  "userType1": @cat  /* {
                        precision: 2,
                }*/
}

TYPE @testWrongRules206
{
  "userType1": @cat  /* {
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules207
{
  "userType1": @cat  /* {
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules208
{
  "userType1": @cat  /* {
                        regex: ".*",
                }*/
}

TYPE @testWrongRules209
{
  "userType1": @cat  /* {
                        minItems: 0,
                }*/
}

TYPE @testWrongRules210
{
  "userType1": @cat  /* {
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules211
{
  "userType1": @cat  /* {
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules212
{
  "userType1": @cat  /* {
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules213
{
  "userType1": @cat  /* {
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules214
{
  "userType1": @cat  /* {
                        enum: ["white", "black"]                            
                }*/
}

# user type

TYPE @testWrongRules215
{
  "userType2": 12 /* {type: "@catId",
                        const: true,
                }*/
}

TYPE @testWrongRules216
{
  "userType2": 12 /* {type: "@catId",
                        min: 0,
                }*/
}

TYPE @testWrongRules217
{
  "userType2": 12 /* {type: "@catId",
                        max: 1,
                }*/
}

TYPE @testWrongRules218
{
  "userType2": 12 /* {type: "@catId",
                        exclusiveMinimum: true,
                }*/
}

TYPE @testWrongRules219
{
  "userType2": 12 /* {type: "@catId",
                        exclusiveMaximum: true,
                }*/
}

TYPE @testWrongRules220
{
  "userType2": 12 /* {type: "@catId",
                        precision: 2,
                }*/
}

TYPE @testWrongRules221
{
  "userType2": 12 /* {type: "@catId",
                        minLength: 0, 
                }*/
}

TYPE @testWrongRules222
{
  "userType2": 12 /* {type: "@catId",
                        maxLength: 100, 
                }*/
}

TYPE @testWrongRules223
{
  "userType2": 12 /* {type: "@catId",
                        regex: ".*",
                }*/
}

TYPE @testWrongRules224
{
  "userType2": 12 /* {type: "@catId",
                        minItems: 0,
                }*/
}

TYPE @testWrongRules225
{
  "userType2": 12 /* {type: "@catId",
                        maxItems: 10,
                }*/
}

TYPE @testWrongRules226
{
  "userType2": 12 /* {type: "@catId",
                        or: [{type: "string"}, {type: "integer"}],
                }*/
}

TYPE @testWrongRules227
{
  "userType2": 12 /* {type: "@catId",
                        additionalProperties: true, 
                }*/
}

TYPE @testWrongRules228
{
  "userType2": 12 /* {type: "@catId",
                        allOf: "@cat",
                }*/
}

TYPE @testWrongRules229
{
  "userType2": 12 /* {type: "@catId",
                        enum: ["white", "black"]                            
                }*/
}

# Helpfull types

TYPE @cat
{
  "catId": @catId,
  "catName": "Tom"
}

TYPE @catId
  12 // {min: 1}