← Back to branch summary

~ubuntu-branches/ubuntu/vivid/phabricator/vivid-proposed

« back to all changes in this revision

Viewing changes to arcanist/src/lint/linter/__tests__/lessc/mixins-guards-default-func.lint-test

  • Committer: Package Import Robot
  • Author(s): Richard Sellam
  • Date: 2014-10-23 20:49:26 UTC
  • mfrom: (0.2.1) (0.1.1)
  • Revision ID: package-import@ubuntu.com-20141023204926-vq80u1op4df44azb
Tags: 0~git20141023-1
http://bugs.debian.org/703046
Initial release (closes: #703046)

Show diffs side-by-side

added added

removed removed

Lines of Context:
arcanist/src/lint/linter/__tests__/lessc/mixins-guards-default-func.lint-test
 
1
 
 
2
// basics:
 
3
 
 
4
guard-default-basic-1 {
 
5
    .m(1)                   {case:     1}
 
6
    .m(@x) when (default()) {default: @x}
 
7
 
 
8
    &-1 {.m(1)}
 
9
    &-2 {.m(2)}
 
10
}
 
11
 
 
12
guard-default-basic-2 {
 
13
    .m(1)                   {case:     1}
 
14
    .m(2)                   {case:     2}
 
15
    .m(3)                   {case:     3}
 
16
    .m(@x) when (default()) {default: @x}
 
17
 
 
18
    &-0 {.m(0)}
 
19
    &-2 {.m(2)}
 
20
}
 
21
 
 
22
guard-default-basic-3 {
 
23
    .m(@x) when (@x = 1)    {case:     1}
 
24
    .m(2)                   {case:     2}
 
25
    .m(@x) when (@x = 3)    {case:     3}
 
26
    .m(@x) when (default()) {default: @x}
 
27
 
 
28
    &-0 {.m(0)}
 
29
    &-2 {.m(2)}
 
30
    &-3 {.m(3)}
 
31
}
 
32
 
 
33
guard-default-definition-order {
 
34
    .m(@x) when (default()) {default: @x}
 
35
    .m(@x) when (@x = 1)    {case:     1}
 
36
    .m(2)                   {case:     2}
 
37
    .m(@x) when (@x = 3)    {case:     3}
 
38
 
 
39
    &-0 {.m(0)}
 
40
    &-2 {.m(2)}
 
41
    &-2 {.m(3)}
 
42
}
 
43
 
 
44
// out of guard:
 
45
 
 
46
guard-default-out-of-guard {
 
47
    .m(1)                              {case-1:   1}
 
48
    .m(@x: default()) when (default()) {default: @x}
 
49
    
 
50
    &-0 {
 
51
        case-0: default();
 
52
        .m(1);
 
53
        .m(2);
 
54
        case-2: default();
 
55
    }
 
56
    &-1 {.m(default())}
 
57
    &-2 {.m()}
 
58
}
 
59
 
 
60
// expressions:
 
61
 
 
62
guard-default-expr-not {
 
63
    .m(1)                      {case:     1}
 
64
    .m(@x) when not(default()) {default: @x}
 
65
 
 
66
    &-1 {.m(1)}
 
67
    &-2 {.m(2)}
 
68
}
 
69
 
 
70
guard-default-expr-eq {
 
71
    .m(@x) when (@x = true)      {case:    @x}
 
72
    .m(@x) when (@x = false)     {case:    @x}
 
73
    .m(@x) when (@x = default()) {default: @x}
 
74
 
 
75
    &-true  {.m(true)}
 
76
    &-false {.m(false)}
 
77
}
 
78
 
 
79
guard-default-expr-or {
 
80
    .m(1)                             {case:     1}
 
81
    .m(2)                             {case:     2}
 
82
    .m(@x) when (default()), (@x = 2) {default: @x}
 
83
 
 
84
    &-1 {.m(1)}
 
85
    &-2 {.m(2)}
 
86
    &-3 {.m(3)}
 
87
}
 
88
 
 
89
guard-default-expr-and {
 
90
    .m(1)                                {case:     1}
 
91
    .m(2)                                {case:     2}
 
92
    .m(@x) when (default()) and (@x = 3) {default: @x}
 
93
 
 
94
    &-1 {.m(1)}
 
95
    &-2 {.m(2)}
 
96
    &-3 {.m(3)}
 
97
    &-4 {.m(4)}
 
98
}
 
99
 
 
100
guard-default-expr-always {
 
101
    .m(1)                                   {case:     1}
 
102
    .m(@x) when (default()), not(default()) {default: @x} // always match
 
103
 
 
104
    &-1 {.m(1)}
 
105
    &-2 {.m(2)}
 
106
}
 
107
 
 
108
guard-default-expr-never {
 
109
    .m(1)                                      {case:     1}
 
110
    .m(@x) when (default()) and not(default()) {default: @x} // never match
 
111
 
 
112
    &-1 {.m(1)}
 
113
    &-2 {.m(2)}
 
114
}
 
115
 
 
116
 
 
117
// not conflicting multiple default() uses:
 
118
 
 
119
guard-default-multi-1 {
 
120
    .m(0)                   {case:       0}
 
121
    .m(@x) when (default()) {default-1: @x}
 
122
    .m(2)  when (default()) {default-2: @x}
 
123
 
 
124
    &-0 {.m(0)}
 
125
    &-1 {.m(1)}
 
126
}
 
127
 
 
128
guard-default-multi-2 {
 
129
    .m(1, @x)   when (default()) {default-1: @x}
 
130
    .m(2, @x)   when (default()) {default-2: @x}
 
131
    .m(@x, yes) when (default()) {default-3: @x}
 
132
 
 
133
    &-1 {.m(1, no)}
 
134
    &-2 {.m(2, no)}
 
135
    &-3 {.m(3, yes)}
 
136
}
 
137
 
 
138
guard-default-multi-3 {
 
139
    .m(red)                                    {case-1: darkred}
 
140
    .m(blue)                                   {case-2: darkblue}
 
141
    .m(@x) when (iscolor(@x)) and (default())  {default-color: @x}
 
142
    .m('foo')                                  {case-1: I am 'foo'}
 
143
    .m('bar')                                  {case-2: I am 'bar'}
 
144
    .m(@x) when (isstring(@x)) and (default()) {default-string: I am @x}
 
145
 
 
146
    &-blue  {.m(blue)}
 
147
    &-green {.m(green)}
 
148
    &-foo   {.m('foo')}
 
149
    &-baz   {.m('baz')}
 
150
}
 
151
 
 
152
guard-default-multi-4 {
 
153
    .m(@x) when (default()), not(default())    {always: @x}
 
154
    .m(@x) when (default()) and not(default()) {never:  @x}
 
155
    .m(2)                                      {case:    2}
 
156
    
 
157
    .m(1);
 
158
    .m(2);
 
159
}
 
160
 
 
161
guard-default-not-ambiguos-2 {
 
162
    .m(@x)                     {case:         1}
 
163
    .m(@x) when (default())    {default:     @x}
 
164
    .m(@x) when not(default()) {not-default: @x}
 
165
 
 
166
    .m(2);
 
167
}
 
168
 
 
169
guard-default-not-ambiguos-3 {
 
170
    .m(@x)                     {case:           1}
 
171
    .m(@x) when not(default()) {not-default-1: @x}
 
172
    .m(@x) when not(default()) {not-default-2: @x}
 
173
 
 
174
    .m(2);
 
175
}
 
176
 
 
177
// default & scope
 
178
 
 
179
guard-default-scopes {
 
180
    .s1() {.m(@v)                  {1: no condition}}
 
181
    .s2() {.m(@v) when (@v)        {2: when true}}
 
182
    .s3() {.m(@v) when (default()) {3: when default}}
 
183
 
 
184
    &-3 {
 
185
        .s2();
 
186
        .s3();
 
187
        .m(false);
 
188
    }
 
189
    
 
190
    &-1 {
 
191
        .s1();
 
192
        .s3();
 
193
        .m(false);
 
194
    }
 
195
}
 
196
~~~~~~~~~~