pym/portage/tests/dep/test_use_reduce.py

   1 # Copyright 2009-2010 Gentoo Foundation
   2 # Distributed under the terms of the GNU General Public License v2
   3
   4 from portage.tests import TestCase
   5 from portage.exception import InvalidDependString
   6 from portage.dep import Atom, use_reduce
   7
   8 class UseReduceTestCase(object):
   9         def __init__(self, deparray, uselist=[], masklist=[], \
  10                 matchall=0, excludeall=[], is_src_uri=False, \
  11                 eapi=None, opconvert=False, flat=False, expected_result=None, \
  12                         is_valid_flag=None, token_class=None):
  13                 self.deparray = deparray
  14                 self.uselist = uselist
  15                 self.masklist = masklist
  16                 self.matchall = matchall
  17                 self.excludeall = excludeall
  18                 self.is_src_uri = is_src_uri
  19                 self.eapi = eapi
  20                 self.opconvert = opconvert
  21                 self.flat = flat
  22                 self.is_valid_flag = is_valid_flag
  23                 self.token_class = token_class
  24                 self.expected_result = expected_result
  25
  26         def run(self):
  27                 return use_reduce(self.deparray, self.uselist, self.masklist, \
  28                         self.matchall, self.excludeall, self.is_src_uri, self.eapi, \
  29                                 self.opconvert, self.flat, self.is_valid_flag, self.token_class)
  30
  31 class UseReduce(TestCase):
  32
  33         def always_true(self, ununsed_parameter):
  34                 return True
  35
  36         def always_false(self, ununsed_parameter):
  37                 return False
  38
  39         def testUseReduce(self):
  40
  41                 EAPI_WITH_SRC_URI_ARROWS = "2"
  42                 EAPI_WITHOUT_SRC_URI_ARROWS = "0"
  43
  44                 test_cases = (
  45                         UseReduceTestCase(
  46                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  47                                 uselist = ["a", "b", "c", "d"],
  48                                 expected_result = ["A", "B"]
  49                                 ),
  50                         UseReduceTestCase(
  51                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  52                                 uselist = ["a", "b", "c"],
  53                                 expected_result = ["A", "B", "D"]
  54                                 ),
  55                         UseReduceTestCase(
  56                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  57                                 uselist = ["b", "c"],
  58                                 expected_result = ["B", "D"]
  59                                 ),
  60
  61                         UseReduceTestCase(
  62                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  63                                 matchall = True,
  64                                 expected_result = ["A", "B", "C", "D"]
  65                                 ),
  66                         UseReduceTestCase(
  67                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  68                                 masklist = ["a", "c"],
  69                                 expected_result = ["C", "D"]
  70                                 ),
  71                         UseReduceTestCase(
  72                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  73                                 matchall = True,
  74                                 masklist = ["a", "c"],
  75                                 expected_result = ["B", "C", "D"]
  76                                 ),
  77                         UseReduceTestCase(
  78                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  79                                 uselist = ["a", "b"],
  80                                 masklist = ["a", "c"],
  81                                 expected_result = ["B", "C", "D"]
  82                                 ),
  83                         UseReduceTestCase(
  84                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  85                                 excludeall = ["a", "c"],
  86                                 expected_result = ["D"]
  87                                 ),
  88                         UseReduceTestCase(
  89                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  90                                 uselist = ["b"],
  91                                 excludeall = ["a", "c"],
  92                                 expected_result = ["B", "D"]
  93                                 ),
  94                         UseReduceTestCase(
  95                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
  96                                 matchall = True,
  97                                 excludeall = ["a", "c"],
  98                                 expected_result = ["A", "B", "D"]
  99                                 ),
 100                         UseReduceTestCase(
 101                                 "a? ( A ) b? ( B ) !c? ( C ) !d? ( D )",
 102                                 matchall = True,
 103                                 excludeall = ["a", "c"],
 104                                 masklist = ["b"],
 105                                 expected_result = ["A", "D"]
 106                                 ),
 107
 108
 109                         UseReduceTestCase(
 110                                 "a? ( b? ( AB ) )",
 111                                 uselist = ["a", "b"],
 112                                 expected_result = ["AB"]
 113                                 ),
 114                         UseReduceTestCase(
 115                                 "a? ( b? ( AB ) C )",
 116                                 uselist = ["a"],
 117                                 expected_result = ["C"]
 118                                 ),
 119                         UseReduceTestCase(
 120                                 "a? ( b? ( || ( AB CD ) ) )",
 121                                 uselist = ["a", "b"],
 122                                 expected_result = ["||", ["AB", "CD"]]
 123                                 ),
 124                         UseReduceTestCase(
 125                                 "|| ( || ( a? ( A ) b? ( B ) ) )",
 126                                 uselist = ["a", "b"],
 127                                 expected_result = ["||", ["A", "B"]]
 128                                 ),
 129                         UseReduceTestCase(
 130                                 "|| ( || ( a? ( A ) b? ( B ) ) )",
 131                                 uselist = ["a"],
 132                                 expected_result = ["A"]
 133                                 ),
 134                         UseReduceTestCase(
 135                                 "|| ( || ( a? ( A ) b? ( B ) ) )",
 136                                 uselist = [],
 137                                 expected_result = []
 138                                 ),
 139                         UseReduceTestCase(
 140                                 "|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
 141                                 uselist = [],
 142                                 expected_result = []
 143                                 ),
 144                         UseReduceTestCase(
 145                                 "|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
 146                                 uselist = ["a"],
 147                                 expected_result = ["A"]
 148                                 ),
 149                         UseReduceTestCase(
 150                                 "|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
 151                                 uselist = ["b"],
 152                                 expected_result = ["B"]
 153                                 ),
 154                         UseReduceTestCase(
 155                                 "|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
 156                                 uselist = ["c"],
 157                                 expected_result = []
 158                                 ),
 159                         UseReduceTestCase(
 160                                 "|| ( || ( a? ( || ( A c? ( C ) ) ) b? ( B ) ) )",
 161                                 uselist = ["a", "c"],
 162                                 expected_result = ["||", [ "A", "C"]]
 163                                 ),
 164
 165                         #paren_reduce tests
 166                         UseReduceTestCase(
 167                                 "A",
 168                                 expected_result = ["A"]),
 169                         UseReduceTestCase(
 170                                 "( A )",
 171                                 expected_result = ["A"]),
 172                         UseReduceTestCase(
 173                                 "|| ( A B )",
 174                                 expected_result = [ "||", ["A", "B"] ]),
 175                         UseReduceTestCase(
 176                                 "|| ( ( A B ) C )",
 177                                 expected_result = [ "||", [ ["A", "B"], "C"] ]),
 178                         UseReduceTestCase(
 179                                 "|| ( ( A B ) ( C ) )",
 180                                 expected_result = [ "||", [ ["A", "B"], "C"] ]),
 181                         UseReduceTestCase(
 182                                 "|| ( A || ( B C ) )",
 183                                 expected_result = [ "||", ["A", "B", "C"]]),
 184                         UseReduceTestCase(
 185                                 "|| ( A || ( B C D ) )",
 186                                 expected_result = [ "||", ["A", "B", "C", "D"] ]),
 187                         UseReduceTestCase(
 188                                 "|| ( A || ( B || ( C D ) E ) )",
 189                                 expected_result = [ "||", ["A", "B", "C", "D", "E"] ]),
 190                         UseReduceTestCase(
 191                                 "( || ( ( ( A ) B ) ) )",
 192                                 expected_result = ["A", "B"] ),
 193                         UseReduceTestCase(
 194                                 "( || ( || ( ( A ) B ) ) )",
 195                                 expected_result = [ "||", ["A", "B"] ]),
 196                         UseReduceTestCase(
 197                                 "( || ( || ( ( A ) B ) ) )",
 198                                 expected_result = [ "||", ["A", "B"] ]),
 199                         UseReduceTestCase(
 200                                 "|| ( A )",
 201                                 expected_result = ["A"]),
 202                         UseReduceTestCase(
 203                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 204                                 expected_result = ["A"]),
 205                         UseReduceTestCase(
 206                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 207                                 uselist = ["foo"],
 208                                 expected_result = [ "||", ["A", "B"] ]),
 209                         UseReduceTestCase(
 210                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 211                                 expected_result = []),
 212                         UseReduceTestCase(
 213                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 214                                 uselist = ["foo", "bar"],
 215                                 expected_result = [ "||", [ "A", "B" ] ]),
 216                         UseReduceTestCase(
 217                                 "A || ( ) foo? ( ) B",
 218                                 expected_result = ["A", "B"]),
 219                         UseReduceTestCase(
 220                                 "|| ( A ) || ( B )",
 221                                 expected_result = ["A", "B"]),
 222                         UseReduceTestCase(
 223                                 "foo? ( A ) foo? ( B )",
 224                                 expected_result = []),
 225                         UseReduceTestCase(
 226                                 "foo? ( A ) foo? ( B )",
 227                                 uselist = ["foo"],
 228                                 expected_result = ["A", "B"]),
 229
 230                         #SRC_URI stuff
 231                         UseReduceTestCase(
 232                                 "http://foo/bar -> blah.tbz2",
 233                                 is_src_uri = True,
 234                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 235                                 expected_result = ["http://foo/bar", "->", "blah.tbz2"]),
 236                         UseReduceTestCase(
 237                                 "foo? ( http://foo/bar -> blah.tbz2 )",
 238                                 uselist = [],
 239                                 is_src_uri = True,
 240                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 241                                 expected_result = []),
 242                         UseReduceTestCase(
 243                                 "foo? ( http://foo/bar -> blah.tbz2 )",
 244                                 uselist = ["foo"],
 245                                 is_src_uri = True,
 246                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 247                                 expected_result = ["http://foo/bar", "->", "blah.tbz2"]),
 248                         UseReduceTestCase(
 249                                 "http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )",
 250                                 uselist = [],
 251                                 is_src_uri = True,
 252                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 253                                 expected_result = ["http://foo/bar", "->", "bar.tbz2"]),
 254                         UseReduceTestCase(
 255                                 "http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )",
 256                                 uselist = ["foo"],
 257                                 is_src_uri = True,
 258                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 259                                 expected_result = ["http://foo/bar", "->", "bar.tbz2", "ftp://foo/a"]),
 260                         UseReduceTestCase(
 261                                 "http://foo.com/foo http://foo/bar -> blah.tbz2",
 262                                 uselist = ["foo"],
 263                                 is_src_uri = True,
 264                                 eapi = EAPI_WITH_SRC_URI_ARROWS,
 265                                 expected_result = ["http://foo.com/foo", "http://foo/bar", "->", "blah.tbz2"]),
 266
 267                         #opconvert tests
 268                         UseReduceTestCase(
 269                                 "A",
 270                                 opconvert = True,
 271                                 expected_result = ["A"]),
 272                         UseReduceTestCase(
 273                                 "( A )",
 274                                 opconvert = True,
 275                                 expected_result = ["A"]),
 276                         UseReduceTestCase(
 277                                 "|| ( A B )",
 278                                 opconvert = True,
 279                                 expected_result = ["||", "A", "B"]),
 280                         UseReduceTestCase(
 281                                 "|| ( ( A B ) C )",
 282                                 opconvert = True,
 283                                 expected_result = [ "||", ["A", "B"], "C" ]),
 284                         UseReduceTestCase(
 285                                 "|| ( A || ( B C ) )",
 286                                 opconvert = True,
 287                                 expected_result = ["||", "A", "B", "C"]),
 288                         UseReduceTestCase(
 289                                 "|| ( A || ( B C D ) )",
 290                                 opconvert = True,
 291                                 expected_result = ["||", "A", "B", "C", "D"]),
 292                         UseReduceTestCase(
 293                                 "|| ( A || ( B || ( C D ) E ) )",
 294                                 expected_result = [ "||", ["A", "B", "C", "D", "E"] ]),
 295                         UseReduceTestCase(
 296                                 "( || ( ( ( A ) B ) ) )",
 297                                 opconvert = True,
 298                                 expected_result = [ "A", "B" ] ),
 299                         UseReduceTestCase(
 300                                 "( || ( || ( ( A ) B ) ) )",
 301                                 opconvert = True,
 302                                 expected_result = ["||", "A", "B"]),
 303                         UseReduceTestCase(
 304                                 "( || ( || ( ( A ) B ) ) )",
 305                                 opconvert = True,
 306                                 expected_result = ["||", "A", "B"]),
 307                         UseReduceTestCase(
 308                                 "|| ( A )",
 309                                 opconvert = True,
 310                                 expected_result = ["A"]),
 311                         UseReduceTestCase(
 312                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 313                                 expected_result = ["A"]),
 314                         UseReduceTestCase(
 315                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 316                                 uselist = ["foo"],
 317                                 opconvert = True,
 318                                 expected_result = ["||", "A", "B"]),
 319                         UseReduceTestCase(
 320                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 321                                 opconvert = True,
 322                                 expected_result = []),
 323                         UseReduceTestCase(
 324                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 325                                 uselist = ["foo", "bar"],
 326                                 opconvert = True,
 327                                 expected_result = ["||", "A", "B"]),
 328                         UseReduceTestCase(
 329                                 "A || ( ) foo? ( ) B",
 330                                 opconvert = True,
 331                                 expected_result = ["A", "B"]),
 332                         UseReduceTestCase(
 333                                 "|| ( A ) || ( B )",
 334                                 opconvert = True,
 335                                 expected_result = ["A", "B"]),
 336                         UseReduceTestCase(
 337                                 "foo? ( A ) foo? ( B )",
 338                                 opconvert = True,
 339                                 expected_result = []),
 340                         UseReduceTestCase(
 341                                 "foo? ( A ) foo? ( B )",
 342                                 uselist = ["foo"],
 343                                 opconvert = True,
 344                                 expected_result = ["A", "B"]),
 345                         UseReduceTestCase(
 346                                 "|| ( foo? ( || ( A B ) ) )",
 347                                 uselist = ["foo"],
 348                                 opconvert = True,
 349                                 expected_result = ["||", "A", "B"]),
 350
 351                         UseReduceTestCase(
 352                                 "|| ( ( A B ) foo? ( || ( C D ) ) )",
 353                                 uselist = ["foo"],
 354                                 opconvert = True,
 355                                 expected_result = ['||', ['A', 'B'], 'C', 'D']),
 356
 357                         UseReduceTestCase(
 358                                 "|| ( ( A B ) foo? ( || ( C D ) ) )",
 359                                 uselist = ["foo"],
 360                                 opconvert = False,
 361                                 expected_result = ['||', [['A', 'B'], 'C', 'D']]),
 362
 363                         UseReduceTestCase(
 364                                 "|| ( ( A B ) || ( C D ) )",
 365                                 expected_result = ['||', [['A', 'B'], 'C', 'D']]),
 366
 367                         UseReduceTestCase(
 368                                 "|| ( ( A B ) || ( C D || ( E ( F G ) || ( H ) ) ) )",
 369                                 expected_result = ['||', [['A', 'B'], 'C', 'D', 'E', ['F', 'G'], 'H']]),
 370
 371                         UseReduceTestCase(
 372                                 "|| ( foo? ( A B ) )",
 373                                 uselist = ["foo"],
 374                                 expected_result = ['A', 'B']),
 375
 376                         UseReduceTestCase(
 377                                 "|| ( || ( foo? ( A B ) ) )",
 378                                 uselist = ["foo"],
 379                                 expected_result = ['A', 'B']),
 380
 381                         UseReduceTestCase(
 382                                 "|| ( || ( || ( a? ( b? ( c? ( || ( || ( || ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) )",
 383                                 uselist = ["a", "b", "c", "d", "e", "f"],
 384                                 expected_result = ['A', 'B']),
 385
 386                         UseReduceTestCase(
 387                                 "|| ( || ( ( || ( a? ( ( b? ( c? ( || ( || ( || ( ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) ) ) ) )",
 388                                 uselist = ["a", "b", "c", "d", "e", "f"],
 389                                 expected_result = ['A', 'B']),
 390
 391                         UseReduceTestCase(
 392                                 "|| ( ( A ( || ( B ) ) ) )",
 393                                 expected_result = ['A', 'B']),
 394
 395                         UseReduceTestCase(
 396                                 "|| ( ( A B ) || ( foo? ( bar? ( ( C D || ( baz? ( E ) ( F G ) || ( H ) ) ) ) ) ) )",
 397                                 uselist = ["foo", "bar", "baz"],
 398                                 expected_result = ['||', [['A', 'B'], 'C', 'D', '||', ['E', ['F', 'G'], 'H']]]),
 399
 400                         UseReduceTestCase(
 401                                 "|| ( foo? ( A B ) )",
 402                                 uselist = ["foo"],
 403                                 opconvert=True,
 404                                 expected_result = ['A', 'B']),
 405
 406                         UseReduceTestCase(
 407                                 "|| ( || ( foo? ( A B ) ) )",
 408                                 uselist = ["foo"],
 409                                 opconvert=True,
 410                                 expected_result = ['A', 'B']),
 411
 412                         UseReduceTestCase(
 413                                 "|| ( || ( || ( a? ( b? ( c? ( || ( || ( || ( d? ( e? ( f? ( A B ) ) ) ) ) ) ) ) ) ) ) )",
 414                                 uselist = ["a", "b", "c", "d", "e", "f"],
 415                                 opconvert=True,
 416                                 expected_result = ['A', 'B']),
 417
 418                         #flat test
 419                         UseReduceTestCase(
 420                                 "A",
 421                                 flat = True,
 422                                 expected_result = ["A"]),
 423                         UseReduceTestCase(
 424                                 "( A )",
 425                                 flat = True,
 426                                 expected_result = ["A"]),
 427                         UseReduceTestCase(
 428                                 "|| ( A B )",
 429                                 flat = True,
 430                                 expected_result = [ "||", "A", "B" ] ),
 431                         UseReduceTestCase(
 432                                 "|| ( A || ( B C ) )",
 433                                 flat = True,
 434                                 expected_result = [ "||", "A", "||", "B", "C" ]),
 435                         UseReduceTestCase(
 436                                 "|| ( A || ( B C D ) )",
 437                                 flat = True,
 438                                 expected_result = [ "||", "A", "||", "B", "C", "D" ]),
 439                         UseReduceTestCase(
 440                                 "|| ( A || ( B || ( C D ) E ) )",
 441                                 flat = True,
 442                                 expected_result = [ "||", "A", "||", "B", "||", "C", "D", "E" ]),
 443                         UseReduceTestCase(
 444                                 "( || ( ( ( A ) B ) ) )",
 445                                 flat = True,
 446                                 expected_result = [ "||", "A", "B"] ),
 447                         UseReduceTestCase(
 448                                 "( || ( || ( ( A ) B ) ) )",
 449                                 flat = True,
 450                                 expected_result = [ "||", "||", "A", "B" ]),
 451                         UseReduceTestCase(
 452                                 "( || ( || ( ( A ) B ) ) )",
 453                                 flat = True,
 454                                 expected_result = [ "||", "||", "A", "B" ]),
 455                         UseReduceTestCase(
 456                                 "|| ( A )",
 457                                 flat = True,
 458                                 expected_result = ["||", "A"]),
 459                         UseReduceTestCase(
 460                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 461                                 expected_result = ["A"]),
 462                         UseReduceTestCase(
 463                                 "( || ( || ( || ( A ) foo? ( B ) ) ) )",
 464                                 uselist = ["foo"],
 465                                 flat = True,
 466                                 expected_result = [ "||", "||","||", "A", "B" ]),
 467                         UseReduceTestCase(
 468                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 469                                 flat = True,
 470                                 expected_result = ["||", "||","||"]),
 471                         UseReduceTestCase(
 472                                 "( || ( || ( bar? ( A ) || ( foo? ( B ) ) ) ) )",
 473                                 uselist = ["foo", "bar"],
 474                                 flat = True,
 475                                 expected_result = [ "||", "||", "A", "||", "B" ]),
 476                         UseReduceTestCase(
 477                                 "A || ( ) foo? ( ) B",
 478                                 flat = True,
 479                                 expected_result = ["A", "||", "B"]),
 480                         UseReduceTestCase(
 481                                 "|| ( A ) || ( B )",
 482                                 flat = True,
 483                                 expected_result = ["||", "A", "||", "B"]),
 484                         UseReduceTestCase(
 485                                 "foo? ( A ) foo? ( B )",
 486                                 flat = True,
 487                                 expected_result = []),
 488                         UseReduceTestCase(
 489                                 "foo? ( A ) foo? ( B )",
 490                                 uselist = ["foo"],
 491                                 flat = True,
 492                                 expected_result = ["A", "B"]),
 493
 494                         #use flag validation
 495                         UseReduceTestCase(
 496                                 "foo? ( A )",
 497                                 uselist = ["foo"],
 498                                 is_valid_flag = self.always_true,
 499                                 expected_result = ["A"]),
 500                         UseReduceTestCase(
 501                                 "foo? ( A )",
 502                                 is_valid_flag = self.always_true,
 503                                 expected_result = []),
 504
 505                         #token_class
 506                         UseReduceTestCase(
 507                                 "foo? ( dev-libs/A )",
 508                                 uselist = ["foo"],
 509                                 token_class=Atom,
 510                                 expected_result = ["dev-libs/A"]),
 511                         UseReduceTestCase(
 512                                 "foo? ( dev-libs/A )",
 513                                 token_class=Atom,
 514                                 expected_result = []),
 515                 )
 516
 517                 test_cases_xfail = (
 518                         UseReduceTestCase("? ( A )"),
 519                         UseReduceTestCase("!? ( A )"),
 520                         UseReduceTestCase("( A"),
 521                         UseReduceTestCase("A )"),
 522                         UseReduceTestCase("||( A B )"),
 523                         UseReduceTestCase("|| (A B )"),
 524                         UseReduceTestCase("|| ( A B)"),
 525                         UseReduceTestCase("|| ( A B"),
 526                         UseReduceTestCase("|| A B )"),
 527                         UseReduceTestCase("|| A B"),
 528                         UseReduceTestCase("|| ( A B ) )"),
 529                         UseReduceTestCase("|| || B C"),
 530                         UseReduceTestCase("|| ( A B || )"),
 531                         UseReduceTestCase("a? A"),
 532                         UseReduceTestCase("( || ( || || ( A ) foo? ( B ) ) )"),
 533                         UseReduceTestCase("( || ( || bar? ( A ) foo? ( B ) ) )"),
 534                         UseReduceTestCase("foo?"),
 535                         UseReduceTestCase("foo? || ( A )"),
 536
 537                         #SRC_URI stuff
 538                         UseReduceTestCase("http://foo/bar -> blah.tbz2", is_src_uri = True, eapi = EAPI_WITHOUT_SRC_URI_ARROWS),
 539                         UseReduceTestCase("|| ( http://foo/bar -> blah.tbz2 )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 540                         UseReduceTestCase("http://foo/bar -> foo? ( ftp://foo/a )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 541                         UseReduceTestCase("http://foo/bar blah.tbz2 ->", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 542                         UseReduceTestCase("-> http://foo/bar blah.tbz2 )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 543                         UseReduceTestCase("http://foo/bar ->", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 544                         UseReduceTestCase("http://foo/bar -> foo? ( http://foo.com/foo )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 545                         UseReduceTestCase("foo? ( http://foo/bar -> ) blah.tbz2", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 546                         UseReduceTestCase("http://foo/bar -> foo/blah.tbz2", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 547                         UseReduceTestCase("http://foo/bar -> -> bar.tbz2 foo? ( ftp://foo/a )", is_src_uri = True, eapi = EAPI_WITH_SRC_URI_ARROWS),
 548
 549                         UseReduceTestCase("http://foo/bar -> bar.tbz2 foo? ( ftp://foo/a )", is_src_uri = False, eapi = EAPI_WITH_SRC_URI_ARROWS),
 550
 551                         UseReduceTestCase(
 552                                 "A",
 553                                 opconvert = True,
 554                                 flat = True),
 555
 556                         #use flag validation
 557                         UseReduceTestCase("1.0? ( A )"),
 558                         UseReduceTestCase("!1.0? ( A )"),
 559                         UseReduceTestCase("!? ( A )"),
 560                         UseReduceTestCase("!?? ( A )"),
 561                         UseReduceTestCase(
 562                                 "foo? ( A )",
 563                                 is_valid_flag = self.always_false,
 564                                 ),
 565                         UseReduceTestCase(
 566                                 "foo? ( A )",
 567                                 uselist = ["foo"],
 568                                 is_valid_flag = self.always_false,
 569                                 ),
 570
 571                         #token_class
 572                         UseReduceTestCase(
 573                                 "foo? ( A )",
 574                                 uselist = ["foo"],
 575                                 token_class=Atom),
 576                         UseReduceTestCase(
 577                                 "A(B",
 578                                 token_class=Atom),
 579                 )
 580
 581                 for test_case in test_cases:
 582                         # If it fails then show the input, since lots of our
 583                         # test cases have the same output but different input,
 584                         # making it difficult deduce which test has failed.
 585                         self.assertEqual(test_case.run(), test_case.expected_result,
 586                                 "input: '%s' result: %s != %s" % (test_case.deparray,
 587                                 test_case.run(), test_case.expected_result))
 588
 589                 for test_case in test_cases_xfail:
 590                         self.assertRaisesMsg(test_case.deparray, (InvalidDependString, ValueError), test_case.run)