• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2* Copyright (c) Microsoft Corporation. All rights reserved.
3* Copyright (c) 2023 Huawei Device Co., Ltd.
4* Licensed under the Apache License, Version 2.0 (the "License");
5* you may not use this file except in compliance with the License.
6* You may obtain a copy of the License at
7*
8*     http://www.apache.org/licenses/LICENSE-2.0
9*
10* Unless required by applicable law or agreed to in writing, software
11* distributed under the License is distributed on an "AS IS" BASIS,
12* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13* See the License for the specific language governing permissions and
14* limitations under the License.
15*
16* This file has been modified by Huawei to verify type inference by adding verification statements.
17*/
18
19// === tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalObjects.ts ===
20declare function AssertType(value:any, type:string):void;
21class A1 {
22    public a: string;
23    public b: number;
24    public c: boolean;
25    public d: any;
26    public e: Object;
27    public fn(a: string): string {
28AssertType(null, "null");
29        return null;
30    }
31}
32class B1 {
33    public a: string;
34    public b: number;
35    public c: boolean;
36    public d: any;
37    public e: Object;
38    public fn(b: string): string {
39AssertType(null, "null");
40        return null;
41    }
42}
43
44class Base {
45    private a: string;
46    private fn(b: string): string {
47AssertType(null, "null");
48        return null;
49    }
50}
51class A2 extends Base { }
52class B2 extends Base { }
53
54interface A3 { f(a: number): string; }
55interface B3 { f(a: number): string; }
56
57interface A4 { new (a: string): A1; }
58interface B4 { new (a: string): B1; }
59
60interface A5 { [x: number]: number; }
61interface B5 { [x: number]: number; }
62
63interface A6 { [x: string]: string; }
64interface B6 { [x: string]: string; }
65
66let a1: A1;
67AssertType(a1, "A1");
68
69let a2: A2;
70AssertType(a2, "A2");
71
72let a3: A3;
73AssertType(a3, "A3");
74
75let a4: A4;
76AssertType(a4, "A4");
77
78let a5: A5;
79AssertType(a5, "A5");
80
81let a6: A6;
82AssertType(a6, "A6");
83
84let b1: B1;
85AssertType(b1, "B1");
86
87let b2: B2;
88AssertType(b2, "B2");
89
90let b3: B3;
91AssertType(b3, "B3");
92
93let b4: B4;
94AssertType(b4, "B4");
95
96let b5: B5;
97AssertType(b5, "B5");
98
99let b6: B6;
100AssertType(b6, "B6");
101
102let base1: Base;
103AssertType(base1, "Base");
104
105let base2: Base;
106AssertType(base2, "Base");
107
108// operator <
109let r1a1 = a1 < b1;
110AssertType(r1a1, "boolean");
111AssertType(a1 < b1, "boolean");
112AssertType(a1, "A1");
113AssertType(b1, "B1");
114
115let r1a2 = base1 < base2;
116AssertType(r1a2, "boolean");
117AssertType(base1 < base2, "boolean");
118AssertType(base1, "Base");
119AssertType(base2, "Base");
120
121let r1a3 = a2 < b2;
122AssertType(r1a3, "boolean");
123AssertType(a2 < b2, "boolean");
124AssertType(a2, "A2");
125AssertType(b2, "B2");
126
127let r1a4 = a3 < b3;
128AssertType(r1a4, "boolean");
129AssertType(a3 < b3, "boolean");
130AssertType(a3, "A3");
131AssertType(b3, "B3");
132
133let r1a5 = a4 < b4;
134AssertType(r1a5, "boolean");
135AssertType(a4 < b4, "boolean");
136AssertType(a4, "A4");
137AssertType(b4, "B4");
138
139let r1a6 = a5 < b5;
140AssertType(r1a6, "boolean");
141AssertType(a5 < b5, "boolean");
142AssertType(a5, "A5");
143AssertType(b5, "B5");
144
145let r1a7 = a6 < b6;
146AssertType(r1a7, "boolean");
147AssertType(a6 < b6, "boolean");
148AssertType(a6, "A6");
149AssertType(b6, "B6");
150
151let r1b1 = b1 < a1;
152AssertType(r1b1, "boolean");
153AssertType(b1 < a1, "boolean");
154AssertType(b1, "B1");
155AssertType(a1, "A1");
156
157let r1b2 = base2 < base1;
158AssertType(r1b2, "boolean");
159AssertType(base2 < base1, "boolean");
160AssertType(base2, "Base");
161AssertType(base1, "Base");
162
163let r1b3 = b2 < a2;
164AssertType(r1b3, "boolean");
165AssertType(b2 < a2, "boolean");
166AssertType(b2, "B2");
167AssertType(a2, "A2");
168
169let r1b4 = b3 < a3;
170AssertType(r1b4, "boolean");
171AssertType(b3 < a3, "boolean");
172AssertType(b3, "B3");
173AssertType(a3, "A3");
174
175let r1b5 = b4 < a4;
176AssertType(r1b5, "boolean");
177AssertType(b4 < a4, "boolean");
178AssertType(b4, "B4");
179AssertType(a4, "A4");
180
181let r1b6 = b5 < a5;
182AssertType(r1b6, "boolean");
183AssertType(b5 < a5, "boolean");
184AssertType(b5, "B5");
185AssertType(a5, "A5");
186
187let r1b7 = b6 < a6;
188AssertType(r1b7, "boolean");
189AssertType(b6 < a6, "boolean");
190AssertType(b6, "B6");
191AssertType(a6, "A6");
192
193// operator >
194let r2a1 = a1 > b1;
195AssertType(r2a1, "boolean");
196AssertType(a1 > b1, "boolean");
197AssertType(a1, "A1");
198AssertType(b1, "B1");
199
200let r2a2 = base1 > base2;
201AssertType(r2a2, "boolean");
202AssertType(base1 > base2, "boolean");
203AssertType(base1, "Base");
204AssertType(base2, "Base");
205
206let r2a3 = a2 > b2;
207AssertType(r2a3, "boolean");
208AssertType(a2 > b2, "boolean");
209AssertType(a2, "A2");
210AssertType(b2, "B2");
211
212let r2a4 = a3 > b3;
213AssertType(r2a4, "boolean");
214AssertType(a3 > b3, "boolean");
215AssertType(a3, "A3");
216AssertType(b3, "B3");
217
218let r2a5 = a4 > b4;
219AssertType(r2a5, "boolean");
220AssertType(a4 > b4, "boolean");
221AssertType(a4, "A4");
222AssertType(b4, "B4");
223
224let r2a6 = a5 > b5;
225AssertType(r2a6, "boolean");
226AssertType(a5 > b5, "boolean");
227AssertType(a5, "A5");
228AssertType(b5, "B5");
229
230let r2a7 = a6 > b6;
231AssertType(r2a7, "boolean");
232AssertType(a6 > b6, "boolean");
233AssertType(a6, "A6");
234AssertType(b6, "B6");
235
236let r2b1 = b1 > a1;
237AssertType(r2b1, "boolean");
238AssertType(b1 > a1, "boolean");
239AssertType(b1, "B1");
240AssertType(a1, "A1");
241
242let r2b2 = base2 > base1;
243AssertType(r2b2, "boolean");
244AssertType(base2 > base1, "boolean");
245AssertType(base2, "Base");
246AssertType(base1, "Base");
247
248let r2b3 = b2 > a2;
249AssertType(r2b3, "boolean");
250AssertType(b2 > a2, "boolean");
251AssertType(b2, "B2");
252AssertType(a2, "A2");
253
254let r2b4 = b3 > a3;
255AssertType(r2b4, "boolean");
256AssertType(b3 > a3, "boolean");
257AssertType(b3, "B3");
258AssertType(a3, "A3");
259
260let r2b5 = b4 > a4;
261AssertType(r2b5, "boolean");
262AssertType(b4 > a4, "boolean");
263AssertType(b4, "B4");
264AssertType(a4, "A4");
265
266let r2b6 = b5 > a5;
267AssertType(r2b6, "boolean");
268AssertType(b5 > a5, "boolean");
269AssertType(b5, "B5");
270AssertType(a5, "A5");
271
272let r2b7 = b6 > a6;
273AssertType(r2b7, "boolean");
274AssertType(b6 > a6, "boolean");
275AssertType(b6, "B6");
276AssertType(a6, "A6");
277
278// operator <=
279let r3a1 = a1 <= b1;
280AssertType(r3a1, "boolean");
281AssertType(a1 <= b1, "boolean");
282AssertType(a1, "A1");
283AssertType(b1, "B1");
284
285let r3a2 = base1 <= base2;
286AssertType(r3a2, "boolean");
287AssertType(base1 <= base2, "boolean");
288AssertType(base1, "Base");
289AssertType(base2, "Base");
290
291let r3a3 = a2 <= b2;
292AssertType(r3a3, "boolean");
293AssertType(a2 <= b2, "boolean");
294AssertType(a2, "A2");
295AssertType(b2, "B2");
296
297let r3a4 = a3 <= b3;
298AssertType(r3a4, "boolean");
299AssertType(a3 <= b3, "boolean");
300AssertType(a3, "A3");
301AssertType(b3, "B3");
302
303let r3a5 = a4 <= b4;
304AssertType(r3a5, "boolean");
305AssertType(a4 <= b4, "boolean");
306AssertType(a4, "A4");
307AssertType(b4, "B4");
308
309let r3a6 = a5 <= b5;
310AssertType(r3a6, "boolean");
311AssertType(a5 <= b5, "boolean");
312AssertType(a5, "A5");
313AssertType(b5, "B5");
314
315let r3a7 = a6 <= b6;
316AssertType(r3a7, "boolean");
317AssertType(a6 <= b6, "boolean");
318AssertType(a6, "A6");
319AssertType(b6, "B6");
320
321let r3b1 = b1 <= a1;
322AssertType(r3b1, "boolean");
323AssertType(b1 <= a1, "boolean");
324AssertType(b1, "B1");
325AssertType(a1, "A1");
326
327let r3b2 = base2 <= base1;
328AssertType(r3b2, "boolean");
329AssertType(base2 <= base1, "boolean");
330AssertType(base2, "Base");
331AssertType(base1, "Base");
332
333let r3b3 = b2 <= a2;
334AssertType(r3b3, "boolean");
335AssertType(b2 <= a2, "boolean");
336AssertType(b2, "B2");
337AssertType(a2, "A2");
338
339let r3b4 = b3 <= a3;
340AssertType(r3b4, "boolean");
341AssertType(b3 <= a3, "boolean");
342AssertType(b3, "B3");
343AssertType(a3, "A3");
344
345let r3b5 = b4 <= a4;
346AssertType(r3b5, "boolean");
347AssertType(b4 <= a4, "boolean");
348AssertType(b4, "B4");
349AssertType(a4, "A4");
350
351let r3b6 = b5 <= a5;
352AssertType(r3b6, "boolean");
353AssertType(b5 <= a5, "boolean");
354AssertType(b5, "B5");
355AssertType(a5, "A5");
356
357let r3b7 = b6 <= a6;
358AssertType(r3b7, "boolean");
359AssertType(b6 <= a6, "boolean");
360AssertType(b6, "B6");
361AssertType(a6, "A6");
362
363// operator >=
364let r4a1 = a1 >= b1;
365AssertType(r4a1, "boolean");
366AssertType(a1 >= b1, "boolean");
367AssertType(a1, "A1");
368AssertType(b1, "B1");
369
370let r4a2 = base1 >= base2;
371AssertType(r4a2, "boolean");
372AssertType(base1 >= base2, "boolean");
373AssertType(base1, "Base");
374AssertType(base2, "Base");
375
376let r4a3 = a2 >= b2;
377AssertType(r4a3, "boolean");
378AssertType(a2 >= b2, "boolean");
379AssertType(a2, "A2");
380AssertType(b2, "B2");
381
382let r4a4 = a3 >= b3;
383AssertType(r4a4, "boolean");
384AssertType(a3 >= b3, "boolean");
385AssertType(a3, "A3");
386AssertType(b3, "B3");
387
388let r4a5 = a4 >= b4;
389AssertType(r4a5, "boolean");
390AssertType(a4 >= b4, "boolean");
391AssertType(a4, "A4");
392AssertType(b4, "B4");
393
394let r4a6 = a5 >= b5;
395AssertType(r4a6, "boolean");
396AssertType(a5 >= b5, "boolean");
397AssertType(a5, "A5");
398AssertType(b5, "B5");
399
400let r4a7 = a6 >= b6;
401AssertType(r4a7, "boolean");
402AssertType(a6 >= b6, "boolean");
403AssertType(a6, "A6");
404AssertType(b6, "B6");
405
406let r4b1 = b1 >= a1;
407AssertType(r4b1, "boolean");
408AssertType(b1 >= a1, "boolean");
409AssertType(b1, "B1");
410AssertType(a1, "A1");
411
412let r4b2 = base2 >= base1;
413AssertType(r4b2, "boolean");
414AssertType(base2 >= base1, "boolean");
415AssertType(base2, "Base");
416AssertType(base1, "Base");
417
418let r4b3 = b2 >= a2;
419AssertType(r4b3, "boolean");
420AssertType(b2 >= a2, "boolean");
421AssertType(b2, "B2");
422AssertType(a2, "A2");
423
424let r4b4 = b3 >= a3;
425AssertType(r4b4, "boolean");
426AssertType(b3 >= a3, "boolean");
427AssertType(b3, "B3");
428AssertType(a3, "A3");
429
430let r4b5 = b4 >= a4;
431AssertType(r4b5, "boolean");
432AssertType(b4 >= a4, "boolean");
433AssertType(b4, "B4");
434AssertType(a4, "A4");
435
436let r4b6 = b5 >= a5;
437AssertType(r4b6, "boolean");
438AssertType(b5 >= a5, "boolean");
439AssertType(b5, "B5");
440AssertType(a5, "A5");
441
442let r4b7 = b6 >= a6;
443AssertType(r4b7, "boolean");
444AssertType(b6 >= a6, "boolean");
445AssertType(b6, "B6");
446AssertType(a6, "A6");
447
448// operator ==
449let r5a1 = a1 == b1;
450AssertType(r5a1, "boolean");
451AssertType(a1 == b1, "boolean");
452AssertType(a1, "A1");
453AssertType(b1, "B1");
454
455let r5a2 = base1 == base2;
456AssertType(r5a2, "boolean");
457AssertType(base1 == base2, "boolean");
458AssertType(base1, "Base");
459AssertType(base2, "Base");
460
461let r5a3 = a2 == b2;
462AssertType(r5a3, "boolean");
463AssertType(a2 == b2, "boolean");
464AssertType(a2, "A2");
465AssertType(b2, "B2");
466
467let r5a4 = a3 == b3;
468AssertType(r5a4, "boolean");
469AssertType(a3 == b3, "boolean");
470AssertType(a3, "A3");
471AssertType(b3, "B3");
472
473let r5a5 = a4 == b4;
474AssertType(r5a5, "boolean");
475AssertType(a4 == b4, "boolean");
476AssertType(a4, "A4");
477AssertType(b4, "B4");
478
479let r5a6 = a5 == b5;
480AssertType(r5a6, "boolean");
481AssertType(a5 == b5, "boolean");
482AssertType(a5, "A5");
483AssertType(b5, "B5");
484
485let r5a7 = a6 == b6;
486AssertType(r5a7, "boolean");
487AssertType(a6 == b6, "boolean");
488AssertType(a6, "A6");
489AssertType(b6, "B6");
490
491let r5b1 = b1 == a1;
492AssertType(r5b1, "boolean");
493AssertType(b1 == a1, "boolean");
494AssertType(b1, "B1");
495AssertType(a1, "A1");
496
497let r5b2 = base2 == base1;
498AssertType(r5b2, "boolean");
499AssertType(base2 == base1, "boolean");
500AssertType(base2, "Base");
501AssertType(base1, "Base");
502
503let r5b3 = b2 == a2;
504AssertType(r5b3, "boolean");
505AssertType(b2 == a2, "boolean");
506AssertType(b2, "B2");
507AssertType(a2, "A2");
508
509let r5b4 = b3 == a3;
510AssertType(r5b4, "boolean");
511AssertType(b3 == a3, "boolean");
512AssertType(b3, "B3");
513AssertType(a3, "A3");
514
515let r5b5 = b4 == a4;
516AssertType(r5b5, "boolean");
517AssertType(b4 == a4, "boolean");
518AssertType(b4, "B4");
519AssertType(a4, "A4");
520
521let r5b6 = b5 == a5;
522AssertType(r5b6, "boolean");
523AssertType(b5 == a5, "boolean");
524AssertType(b5, "B5");
525AssertType(a5, "A5");
526
527let r5b7 = b6 == a6;
528AssertType(r5b7, "boolean");
529AssertType(b6 == a6, "boolean");
530AssertType(b6, "B6");
531AssertType(a6, "A6");
532
533// operator !=
534let r6a1 = a1 != b1;
535AssertType(r6a1, "boolean");
536AssertType(a1 != b1, "boolean");
537AssertType(a1, "A1");
538AssertType(b1, "B1");
539
540let r6a2 = base1 != base2;
541AssertType(r6a2, "boolean");
542AssertType(base1 != base2, "boolean");
543AssertType(base1, "Base");
544AssertType(base2, "Base");
545
546let r6a3 = a2 != b2;
547AssertType(r6a3, "boolean");
548AssertType(a2 != b2, "boolean");
549AssertType(a2, "A2");
550AssertType(b2, "B2");
551
552let r6a4 = a3 != b3;
553AssertType(r6a4, "boolean");
554AssertType(a3 != b3, "boolean");
555AssertType(a3, "A3");
556AssertType(b3, "B3");
557
558let r6a5 = a4 != b4;
559AssertType(r6a5, "boolean");
560AssertType(a4 != b4, "boolean");
561AssertType(a4, "A4");
562AssertType(b4, "B4");
563
564let r6a6 = a5 != b5;
565AssertType(r6a6, "boolean");
566AssertType(a5 != b5, "boolean");
567AssertType(a5, "A5");
568AssertType(b5, "B5");
569
570let r6a7 = a6 != b6;
571AssertType(r6a7, "boolean");
572AssertType(a6 != b6, "boolean");
573AssertType(a6, "A6");
574AssertType(b6, "B6");
575
576let r6b1 = b1 != a1;
577AssertType(r6b1, "boolean");
578AssertType(b1 != a1, "boolean");
579AssertType(b1, "B1");
580AssertType(a1, "A1");
581
582let r6b2 = base2 != base1;
583AssertType(r6b2, "boolean");
584AssertType(base2 != base1, "boolean");
585AssertType(base2, "Base");
586AssertType(base1, "Base");
587
588let r6b3 = b2 != a2;
589AssertType(r6b3, "boolean");
590AssertType(b2 != a2, "boolean");
591AssertType(b2, "B2");
592AssertType(a2, "A2");
593
594let r6b4 = b3 != a3;
595AssertType(r6b4, "boolean");
596AssertType(b3 != a3, "boolean");
597AssertType(b3, "B3");
598AssertType(a3, "A3");
599
600let r6b5 = b4 != a4;
601AssertType(r6b5, "boolean");
602AssertType(b4 != a4, "boolean");
603AssertType(b4, "B4");
604AssertType(a4, "A4");
605
606let r6b6 = b5 != a5;
607AssertType(r6b6, "boolean");
608AssertType(b5 != a5, "boolean");
609AssertType(b5, "B5");
610AssertType(a5, "A5");
611
612let r6b7 = b6 != a6;
613AssertType(r6b7, "boolean");
614AssertType(b6 != a6, "boolean");
615AssertType(b6, "B6");
616AssertType(a6, "A6");
617
618// operator ===
619let r7a1 = a1 === b1;
620AssertType(r7a1, "boolean");
621AssertType(a1 === b1, "boolean");
622AssertType(a1, "A1");
623AssertType(b1, "B1");
624
625let r7a2 = base1 === base2;
626AssertType(r7a2, "boolean");
627AssertType(base1 === base2, "boolean");
628AssertType(base1, "Base");
629AssertType(base2, "Base");
630
631let r7a3 = a2 === b2;
632AssertType(r7a3, "boolean");
633AssertType(a2 === b2, "boolean");
634AssertType(a2, "A2");
635AssertType(b2, "B2");
636
637let r7a4 = a3 === b3;
638AssertType(r7a4, "boolean");
639AssertType(a3 === b3, "boolean");
640AssertType(a3, "A3");
641AssertType(b3, "B3");
642
643let r7a5 = a4 === b4;
644AssertType(r7a5, "boolean");
645AssertType(a4 === b4, "boolean");
646AssertType(a4, "A4");
647AssertType(b4, "B4");
648
649let r7a6 = a5 === b5;
650AssertType(r7a6, "boolean");
651AssertType(a5 === b5, "boolean");
652AssertType(a5, "A5");
653AssertType(b5, "B5");
654
655let r7a7 = a6 === b6;
656AssertType(r7a7, "boolean");
657AssertType(a6 === b6, "boolean");
658AssertType(a6, "A6");
659AssertType(b6, "B6");
660
661let r7b1 = b1 === a1;
662AssertType(r7b1, "boolean");
663AssertType(b1 === a1, "boolean");
664AssertType(b1, "B1");
665AssertType(a1, "A1");
666
667let r7b2 = base2 === base1;
668AssertType(r7b2, "boolean");
669AssertType(base2 === base1, "boolean");
670AssertType(base2, "Base");
671AssertType(base1, "Base");
672
673let r7b3 = b2 === a2;
674AssertType(r7b3, "boolean");
675AssertType(b2 === a2, "boolean");
676AssertType(b2, "B2");
677AssertType(a2, "A2");
678
679let r7b4 = b3 === a3;
680AssertType(r7b4, "boolean");
681AssertType(b3 === a3, "boolean");
682AssertType(b3, "B3");
683AssertType(a3, "A3");
684
685let r7b5 = b4 === a4;
686AssertType(r7b5, "boolean");
687AssertType(b4 === a4, "boolean");
688AssertType(b4, "B4");
689AssertType(a4, "A4");
690
691let r7b6 = b5 === a5;
692AssertType(r7b6, "boolean");
693AssertType(b5 === a5, "boolean");
694AssertType(b5, "B5");
695AssertType(a5, "A5");
696
697let r7b7 = b6 === a6;
698AssertType(r7b7, "boolean");
699AssertType(b6 === a6, "boolean");
700AssertType(b6, "B6");
701AssertType(a6, "A6");
702
703// operator !==
704let r8a1 = a1 !== b1;
705AssertType(r8a1, "boolean");
706AssertType(a1 !== b1, "boolean");
707AssertType(a1, "A1");
708AssertType(b1, "B1");
709
710let r8a2 = base1 !== base2;
711AssertType(r8a2, "boolean");
712AssertType(base1 !== base2, "boolean");
713AssertType(base1, "Base");
714AssertType(base2, "Base");
715
716let r8a3 = a2 !== b2;
717AssertType(r8a3, "boolean");
718AssertType(a2 !== b2, "boolean");
719AssertType(a2, "A2");
720AssertType(b2, "B2");
721
722let r8a4 = a3 !== b3;
723AssertType(r8a4, "boolean");
724AssertType(a3 !== b3, "boolean");
725AssertType(a3, "A3");
726AssertType(b3, "B3");
727
728let r8a5 = a4 !== b4;
729AssertType(r8a5, "boolean");
730AssertType(a4 !== b4, "boolean");
731AssertType(a4, "A4");
732AssertType(b4, "B4");
733
734let r8a6 = a5 !== b5;
735AssertType(r8a6, "boolean");
736AssertType(a5 !== b5, "boolean");
737AssertType(a5, "A5");
738AssertType(b5, "B5");
739
740let r8a7 = a6 !== b6;
741AssertType(r8a7, "boolean");
742AssertType(a6 !== b6, "boolean");
743AssertType(a6, "A6");
744AssertType(b6, "B6");
745
746let r8b1 = b1 !== a1;
747AssertType(r8b1, "boolean");
748AssertType(b1 !== a1, "boolean");
749AssertType(b1, "B1");
750AssertType(a1, "A1");
751
752let r8b2 = base2 !== base1;
753AssertType(r8b2, "boolean");
754AssertType(base2 !== base1, "boolean");
755AssertType(base2, "Base");
756AssertType(base1, "Base");
757
758let r8b3 = b2 !== a2;
759AssertType(r8b3, "boolean");
760AssertType(b2 !== a2, "boolean");
761AssertType(b2, "B2");
762AssertType(a2, "A2");
763
764let r8b4 = b3 !== a3;
765AssertType(r8b4, "boolean");
766AssertType(b3 !== a3, "boolean");
767AssertType(b3, "B3");
768AssertType(a3, "A3");
769
770let r8b5 = b4 !== a4;
771AssertType(r8b5, "boolean");
772AssertType(b4 !== a4, "boolean");
773AssertType(b4, "B4");
774AssertType(a4, "A4");
775
776let r8b6 = b5 !== a5;
777AssertType(r8b6, "boolean");
778AssertType(b5 !== a5, "boolean");
779AssertType(b5, "B5");
780AssertType(a5, "A5");
781
782let r8b7 = b6 !== a6;
783AssertType(r8b7, "boolean");
784AssertType(b6 !== a6, "boolean");
785AssertType(b6, "B6");
786AssertType(a6, "A6");
787
788
789