cython

1

2
cimport cython
3

4
bstring1 = b"abcdefg"
5
bstring2 = b"1234567"
6

7
string1 = "abcdefg"
8
string2 = "1234567"
9

10
ustring1 = u"abcdefg"
11
ustring2 = u"1234567"
12

13
# unicode
14

15
@cython.test_assert_path_exists(
16
    "//PrimaryCmpNode",
17
    "//PrimaryCmpNode[@is_pycmp = False]",
18
)
19
def unicode_eq(unicode s1, unicode s2):
20
    """
21
    >>> unicode_eq(ustring1, ustring1)
22
    True
23
    >>> unicode_eq(ustring1+ustring2, ustring1+ustring2)
24
    True
25
    >>> unicode_eq(ustring1, ustring2)
26
    False
27
    """
28
    return s1 == s2
29

30
@cython.test_assert_path_exists(
31
    "//PrimaryCmpNode",
32
    "//PrimaryCmpNode[@is_pycmp = False]",
33
)
34
def unicode_neq(unicode s1, unicode s2):
35
    """
36
    >>> unicode_neq(ustring1, ustring1)
37
    False
38
    >>> unicode_neq(ustring1+ustring2, ustring1+ustring2)
39
    False
40
    >>> unicode_neq(ustring1, ustring2)
41
    True
42
    """
43
    return s1 != s2
44

45
@cython.test_assert_path_exists(
46
    "//PrimaryCmpNode",
47
    "//PrimaryCmpNode[@is_pycmp = False]",
48
)
49
def unicode_literal_eq(unicode s):
50
    """
51
    >>> unicode_literal_eq(ustring1)
52
    True
53
    >>> unicode_literal_eq((ustring1+ustring2)[:len(ustring1)])
54
    True
55
    >>> unicode_literal_eq(ustring2)
56
    False
57
    """
58
    return s == u"abcdefg"
59

60
@cython.test_assert_path_exists(
61
    "//PrimaryCmpNode",
62
    "//PrimaryCmpNode[@is_pycmp = False]",
63
)
64
def unicode_literal_neq(unicode s):
65
    """
66
    >>> unicode_literal_neq(ustring1)
67
    False
68
    >>> unicode_literal_neq((ustring1+ustring2)[:len(ustring1)])
69
    False
70
    >>> unicode_literal_neq(ustring2)
71
    True
72
    """
73
    return s != u"abcdefg"
74

75
@cython.test_assert_path_exists(
76
    "//PrimaryCmpNode",
77
    "//PrimaryCmpNode[@is_pycmp = False]",
78
    "//CascadedCmpNode"
79
)
80
@cython.test_fail_if_path_exists(
81
    "//CascadedCmpNode[@is_pycmp = True]",
82
    "//PrimaryCmpNode[@is_pycmp = True]",
83
)
84
def unicode_cascade(unicode s1, unicode s2):
85
    """
86
    >>> unicode_cascade(ustring1, ustring1)
87
    True
88
    >>> unicode_cascade(ustring1, (ustring1+ustring2)[:len(ustring1)])
89
    True
90
    >>> unicode_cascade(ustring1, ustring2)
91
    False
92
    """
93
    return s1 == s2 == u"abcdefg"
94

95
@cython.test_assert_path_exists(
96
    "//PrimaryCmpNode",
97
    "//PrimaryCmpNode[@is_pycmp = False]",
98
)
99
def unicode_cascade_untyped_end(unicode s1, unicode s2):
100
    """
101
    >>> unicode_cascade_untyped_end(ustring1, ustring1)
102
    True
103
    >>> unicode_cascade_untyped_end(ustring1, (ustring1+ustring2)[:len(ustring1)])
104
    True
105
    >>> unicode_cascade_untyped_end(ustring1, ustring2)
106
    False
107
    """
108
    return s1 == s2 == u"abcdefg" == (<object>ustring1) == ustring1
109

110
@cython.test_assert_path_exists(
111
    "//PrimaryCmpNode",
112
    "//PrimaryCmpNode[@is_pycmp = False]",
113
)
114
def unicode_cascade_untyped_end_bool(unicode s1, unicode s2):
115
    """
116
    >>> unicode_cascade_untyped_end_bool(ustring1, ustring1)
117
    True
118
    >>> unicode_cascade_untyped_end_bool(ustring1, (ustring1+ustring2)[:len(ustring1)])
119
    True
120
    >>> unicode_cascade_untyped_end_bool(ustring1, ustring2)
121
    False
122
    """
123
    if s1 == s2 == u"abcdefg" == (<object>ustring1) == ustring1:
124
        return True
125
    else:
126
        return False
127

128

129
# str
130

131
@cython.test_assert_path_exists(
132
    "//PrimaryCmpNode",
133
    "//PrimaryCmpNode[@is_pycmp = False]",
134
)
135
def str_eq(str s1, str s2):
136
    """
137
    >>> str_eq(string1, string1)
138
    True
139
    >>> str_eq(string1+string2, string1+string2)
140
    True
141
    >>> str_eq(string1, string2)
142
    False
143
    """
144
    return s1 == s2
145

146
@cython.test_assert_path_exists(
147
    "//PrimaryCmpNode",
148
    "//PrimaryCmpNode[@is_pycmp = False]",
149
)
150
def str_neq(str s1, str s2):
151
    """
152
    >>> str_neq(string1, string1)
153
    False
154
    >>> str_neq(string1+string2, string1+string2)
155
    False
156
    >>> str_neq(string1, string2)
157
    True
158
    """
159
    return s1 != s2
160

161
@cython.test_assert_path_exists(
162
    "//PrimaryCmpNode",
163
    "//PrimaryCmpNode[@is_pycmp = False]",
164
)
165
def str_literal_eq(str s):
166
    """
167
    >>> str_literal_eq(string1)
168
    True
169
    >>> str_literal_eq((string1+string2)[:len(string1)])
170
    True
171
    >>> str_literal_eq(string2)
172
    False
173
    """
174
    return s == "abcdefg"
175

176
@cython.test_assert_path_exists(
177
    "//PrimaryCmpNode",
178
    "//PrimaryCmpNode[@is_pycmp = False]",
179
)
180
def str_literal_neq(str s):
181
    """
182
    >>> str_literal_neq(string1)
183
    False
184
    >>> str_literal_neq((string1+string2)[:len(string1)])
185
    False
186
    >>> str_literal_neq(string2)
187
    True
188
    """
189
    return s != "abcdefg"
190

191
@cython.test_assert_path_exists(
192
    "//PrimaryCmpNode",
193
    "//PrimaryCmpNode[@is_pycmp = False]",
194
)
195
@cython.test_fail_if_path_exists(
196
    "//CascadedCmpNode[@is_pycmp = True]",
197
    "//PrimaryCmpNode[@is_pycmp = True]",
198
)
199
def str_cascade(str s1, str s2):
200
    """
201
    >>> str_cascade(string1, string1)
202
    True
203
    >>> str_cascade(string1, (string1+string2)[:len(string1)])
204
    True
205
    >>> str_cascade(string1, string2)
206
    False
207
    """
208
    return s1 == s2 == "abcdefg"
209

210
@cython.test_assert_path_exists(
211
    "//PrimaryCmpNode",
212
    "//PrimaryCmpNode[@is_pycmp = False]",
213
)
214
def str_cascade_untyped_end(str s1, str s2):
215
    """
216
    >>> str_cascade_untyped_end(string1, string1)
217
    True
218
    >>> str_cascade_untyped_end(string1, (string1+string2)[:len(string1)])
219
    True
220
    >>> str_cascade_untyped_end(string1, string2)
221
    False
222
    """
223
    return s1 == s2 == "abcdefg" == (<object>string1) == string1
224

225
# bytes
226

227
@cython.test_assert_path_exists(
228
    "//PrimaryCmpNode",
229
    "//PrimaryCmpNode[@is_pycmp = False]",
230
)
231
def bytes_eq(bytes s1, bytes s2):
232
    """
233
    >>> bytes_eq(bstring1, bstring1)
234
    True
235
    >>> bytes_eq(bstring1+bstring2, bstring1+bstring2)
236
    True
237
    >>> bytes_eq(bstring1, bstring2)
238
    False
239
    """
240
    return s1 == s2
241

242
@cython.test_assert_path_exists(
243
    "//PrimaryCmpNode",
244
    "//PrimaryCmpNode[@is_pycmp = False]",
245
)
246
def bytes_neq(bytes s1, bytes s2):
247
    """
248
    >>> bytes_neq(bstring1, bstring1)
249
    False
250
    >>> bytes_neq(bstring1+bstring2, bstring1+bstring2)
251
    False
252
    >>> bytes_neq(bstring1, bstring2)
253
    True
254
    """
255
    return s1 != s2
256

257
@cython.test_assert_path_exists(
258
    "//PrimaryCmpNode",
259
    "//PrimaryCmpNode[@is_pycmp = False]",
260
)
261
def bytes_literal_eq(bytes s):
262
    """
263
    >>> bytes_literal_eq(bstring1)
264
    True
265
    >>> bytes_literal_eq((bstring1+bstring2)[:len(bstring1)])
266
    True
267
    >>> bytes_literal_eq(bstring2)
268
    False
269
    """
270
    return s == b"abcdefg"
271

272
@cython.test_assert_path_exists(
273
    "//PrimaryCmpNode",
274
    "//PrimaryCmpNode[@is_pycmp = False]",
275
)
276
def bytes_literal_neq(bytes s):
277
    """
278
    >>> bytes_literal_neq(bstring1)
279
    False
280
    >>> bytes_literal_neq((bstring1+bstring2)[:len(bstring1)])
281
    False
282
    >>> bytes_literal_neq(bstring2)
283
    True
284
    """
285
    return s != b"abcdefg"
286

287
@cython.test_assert_path_exists(
288
    "//PrimaryCmpNode",
289
    "//PrimaryCmpNode[@is_pycmp = False]",
290
)
291
@cython.test_fail_if_path_exists(
292
    "//CascadedCmpNode[@is_pycmp = True]",
293
    "//PrimaryCmpNode[@is_pycmp = True]",
294
)
295
def bytes_cascade(bytes s1, bytes s2):
296
    """
297
    >>> bytes_cascade(bstring1, bstring1)
298
    True
299
    >>> bytes_cascade(bstring1, (bstring1+bstring2)[:len(bstring1)])
300
    True
301
    >>> bytes_cascade(bstring1, bstring2)
302
    False
303
    """
304
    return s1 == s2 == b"abcdefg"
305

306
@cython.test_assert_path_exists(
307
    "//PrimaryCmpNode",
308
    "//PrimaryCmpNode[@is_pycmp = False]",
309
)
310
def bytes_cascade_untyped_end(bytes s1, bytes s2):
311
    """
312
    >>> bytes_cascade_untyped_end(bstring1, bstring1)
313
    True
314
    >>> bytes_cascade_untyped_end(bstring1, (bstring1+bstring2)[:len(bstring1)])
315
    True
316
    >>> bytes_cascade_untyped_end(bstring1, bstring2)
317
    False
318
    """
319
    return s1 == s2 == b"abcdefg" == (<object>bstring1) == bstring1
320

321

322
# basestring
323

324
@cython.test_assert_path_exists(
325
    "//PrimaryCmpNode",
326
    "//PrimaryCmpNode[@is_pycmp = False]",
327
)
328
def basestring_eq(basestring s1, basestring s2):
329
    """
330
    >>> basestring_eq(string1, string1)
331
    True
332
    >>> basestring_eq(string1, ustring1)
333
    True
334
    >>> basestring_eq(string1+string2, string1+string2)
335
    True
336
    >>> basestring_eq(string1+ustring2, ustring1+string2)
337
    True
338
    >>> basestring_eq(string1, string2)
339
    False
340
    >>> basestring_eq(string1, ustring2)
341
    False
342
    >>> basestring_eq(ustring1, string2)
343
    False
344
    """
345
    return s1 == s2
346

347
@cython.test_assert_path_exists(
348
    "//PrimaryCmpNode",
349
    "//PrimaryCmpNode[@is_pycmp = False]",
350
)
351
def basestring_neq(basestring s1, basestring s2):
352
    """
353
    >>> basestring_neq(string1, string1)
354
    False
355
    >>> basestring_neq(string1+string2, string1+string2)
356
    False
357
    >>> basestring_neq(string1+ustring2, ustring1+string2)
358
    False
359
    >>> basestring_neq(string1, string2)
360
    True
361
    >>> basestring_neq(string1, ustring2)
362
    True
363
    >>> basestring_neq(ustring1, string2)
364
    True
365
    """
366
    return s1 != s2
367

368
@cython.test_assert_path_exists(
369
    "//PrimaryCmpNode",
370
    "//PrimaryCmpNode[@is_pycmp = False]",
371
)
372
def basestring_str_literal_eq(basestring s):
373
    """
374
    >>> basestring_str_literal_eq(string1)
375
    True
376
    >>> basestring_str_literal_eq((string1+string2)[:len(string1)])
377
    True
378
    >>> basestring_str_literal_eq(string2)
379
    False
380
    """
381
    return s == "abcdefg"
382

383
@cython.test_assert_path_exists(
384
    "//PrimaryCmpNode",
385
    "//PrimaryCmpNode[@is_pycmp = False]",
386
)
387
def basestring_unicode_literal_eq(basestring s):
388
    """
389
    >>> basestring_unicode_literal_eq(string1)
390
    True
391
    >>> basestring_unicode_literal_eq((string1+string2)[:len(string1)])
392
    True
393
    >>> basestring_unicode_literal_eq(string2)
394
    False
395
    """
396
    return s == u"abcdefg"
397

398
@cython.test_assert_path_exists(
399
    "//PrimaryCmpNode",
400
    "//PrimaryCmpNode[@is_pycmp = False]",
401
)
402
def basestring_str_literal_neq(basestring s):
403
    """
404
    >>> basestring_str_literal_neq(string1)
405
    False
406
    >>> basestring_str_literal_neq((string1+string2)[:len(string1)])
407
    False
408
    >>> basestring_str_literal_neq(string2)
409
    True
410
    """
411
    return s != "abcdefg"
412

413
@cython.test_assert_path_exists(
414
    "//PrimaryCmpNode",
415
    "//PrimaryCmpNode[@is_pycmp = False]",
416
)
417
def basestring_unicode_literal_neq(basestring s):
418
    """
419
    >>> basestring_unicode_literal_neq(string1)
420
    False
421
    >>> basestring_unicode_literal_neq((string1+string2)[:len(string1)])
422
    False
423
    >>> basestring_unicode_literal_neq(string2)
424
    True
425
    """
426
    return s != u"abcdefg"
427

428
@cython.test_assert_path_exists(
429
    "//PrimaryCmpNode",
430
    "//PrimaryCmpNode[@is_pycmp = False]",
431
    "//CascadedCmpNode[@is_pycmp = False]",
432
)
433
@cython.test_fail_if_path_exists(
434
    "//CascadedCmpNode[@is_pycmp = True]",
435
    "//PrimaryCmpNode[@is_pycmp = True]",
436
)
437
def basestring_cascade_str(basestring s1, basestring s2):
438
    """
439
    >>> basestring_cascade_str(string1, string1)
440
    True
441
    >>> basestring_cascade_str(string1, (string1+string2)[:len(string1)])
442
    True
443
    >>> basestring_cascade_str(string1, string2)
444
    False
445
    """
446
    return s1 == s2 == "abcdefg"
447

448
@cython.test_assert_path_exists(
449
    "//PrimaryCmpNode",
450
    "//PrimaryCmpNode[@is_pycmp = False]",
451
    "//CascadedCmpNode[@is_pycmp = False]",
452
)
453
@cython.test_fail_if_path_exists(
454
    "//CascadedCmpNode[@is_pycmp = True]",
455
    "//PrimaryCmpNode[@is_pycmp = True]",
456
)
457
def basestring_cascade_unicode(basestring s1, basestring s2):
458
    """
459
    >>> basestring_cascade_unicode(string1, string1)
460
    True
461
    >>> basestring_cascade_unicode(ustring1, string1)
462
    True
463
    >>> basestring_cascade_unicode(string1, ustring1)
464
    True
465
    >>> basestring_cascade_unicode(string1, (string1+string2)[:len(string1)])
466
    True
467
    >>> basestring_cascade_unicode(string1, string2)
468
    False
469
    >>> basestring_cascade_unicode(ustring1, string2)
470
    False
471
    >>> basestring_cascade_unicode(string1, ustring2)
472
    False
473
    """
474
    return s1 == s2 == u"abcdefg"
475

476
@cython.test_assert_path_exists(
477
    "//PrimaryCmpNode",
478
    "//PrimaryCmpNode[@is_pycmp = False]",
479
)
480
def basestring_cascade_untyped_end(basestring s1, basestring s2):
481
    """
482
    >>> basestring_cascade_untyped_end(string1, string1)
483
    True
484
    >>> basestring_cascade_untyped_end(string1, (string1+string2)[:len(string1)])
485
    True
486
    >>> basestring_cascade_untyped_end(string1, string2)
487
    False
488
    """
489
    return s1 == s2 == "abcdefg" == (<object>string1) == string1
490

491

492
# untyped/literal comparison
493

494
@cython.test_assert_path_exists(
495
    "//PrimaryCmpNode",
496
    "//PrimaryCmpNode[@is_pycmp = False]",
497
)
498
def untyped_unicode_literal_eq_bool(s):
499
    """
500
    >>> untyped_unicode_literal_eq_bool(string1)
501
    True
502
    >>> untyped_unicode_literal_eq_bool(ustring1)
503
    True
504
    >>> untyped_unicode_literal_eq_bool((string1+string2)[:len(string1)])
505
    True
506
    >>> untyped_unicode_literal_eq_bool(string2)
507
    False
508
    >>> untyped_unicode_literal_eq_bool(ustring2)
509
    False
510
    """
511
    return True if s == u"abcdefg" else False
512

513
@cython.test_assert_path_exists(
514
    "//PrimaryCmpNode",
515
    "//PrimaryCmpNode[@is_pycmp = False]",
516
)
517
def untyped_str_literal_eq_bool(s):
518
    """
519
    >>> untyped_str_literal_eq_bool(string1)
520
    True
521
    >>> untyped_str_literal_eq_bool(ustring1)
522
    True
523
    >>> untyped_str_literal_eq_bool((string1+string2)[:len(string1)])
524
    True
525
    >>> untyped_str_literal_eq_bool(string2)
526
    False
527
    >>> untyped_str_literal_eq_bool(ustring2)
528
    False
529
    """
530
    return True if s == "abcdefg" else False
531

532
@cython.test_assert_path_exists(
533
    "//PrimaryCmpNode",
534
    "//PrimaryCmpNode[@is_pycmp = True]",
535
    "//CascadedCmpNode",
536
    "//CascadedCmpNode[@is_pycmp = False]",
537
)
538
@cython.test_fail_if_path_exists(
539
    "//CascadedCmpNode[@is_pycmp = True]",
540
    "//PrimaryCmpNode[@is_pycmp = False]",
541
)
542
def untyped_unicode_cascade(s1, unicode s2):
543
    """
544
    >>> untyped_unicode_cascade(ustring1, ustring1)
545
    True
546
    >>> untyped_unicode_cascade(ustring1, (ustring1+ustring2)[:len(ustring1)])
547
    True
548
    >>> untyped_unicode_cascade(ustring1, ustring2)
549
    False
550
    """
551
    return s1 == s2 == u"abcdefg"
552

553
@cython.test_assert_path_exists(
554
    "//PrimaryCmpNode",
555
    "//PrimaryCmpNode[@is_pycmp = False]",
556
    "//CascadedCmpNode",
557
    "//CascadedCmpNode[@is_pycmp = False]",
558
)
559
@cython.test_fail_if_path_exists(
560
    "//CascadedCmpNode[@is_pycmp = True]",
561
    "//PrimaryCmpNode[@is_pycmp = True]",
562
)
563
def untyped_unicode_cascade_bool(s1, unicode s2):
564
    """
565
    >>> untyped_unicode_cascade_bool(ustring1, ustring1)
566
    True
567
    >>> untyped_unicode_cascade_bool(ustring1, (ustring1+ustring2)[:len(ustring1)])
568
    True
569
    >>> untyped_unicode_cascade_bool(ustring1, ustring2)
570
    False
571
    """
572
    return True if s1 == s2 == u"abcdefg" else False
573

574
@cython.test_assert_path_exists(
575
    "//PrimaryCmpNode",
576
    "//PrimaryCmpNode[@is_pycmp = True]",
577
    "//CascadedCmpNode",
578
#    "//CascadedCmpNode[@is_pycmp = False]",
579
)
580
@cython.test_fail_if_path_exists(
581
    "//CascadedCmpNode[@is_pycmp = True]",
582
    "//PrimaryCmpNode[@is_pycmp = False]",
583
)
584
def untyped_untyped_unicode_cascade_bool(s1, s2):
585
    """
586
    >>> untyped_untyped_unicode_cascade_bool(ustring1, ustring1)
587
    True
588
    >>> untyped_untyped_unicode_cascade_bool(ustring1, (ustring1+ustring2)[:len(ustring1)])
589
    True
590
    >>> untyped_untyped_unicode_cascade_bool(ustring1, ustring2)
591
    False
592
    >>> untyped_untyped_unicode_cascade_bool(string1, string2)
593
    False
594
    >>> untyped_untyped_unicode_cascade_bool(1, 2)
595
    False
596
    >>> untyped_untyped_unicode_cascade_bool(1, 1)
597
    False
598
    """
599
    return True if s1 == s2 == u"abcdefg" else False
600

601

602
# bytes/str comparison
603

604
@cython.test_assert_path_exists(
605
    '//PrimaryCmpNode',
606
    '//PrimaryCmpNode[@operator = "!="]',
607
)
608
def literal_compare_bytes_str():
609
    """
610
    >>> literal_compare_bytes_str()
611
    True
612
    """
613
    # we must not constant fold the subexpressions as the result is Py2/3 sensitive
614
    return b'abc' != 'abc'
615