Move test_fuzz_parser to eng/scripts

tests/suite/test_fuzz_parser.py → eng/scripts/test_fuzz_parser.py

@@ -1,6 +1,6 @@
 MAX_DEPTH = 2
 
-#class StatementGenerator(BaseGenerator): 
+#class StatementGenerator(BaseGenerator):
 #    def generate(self, depth): raise NotImplementedError
 
 ######################################################################
@@ -12,7 +12,7 @@ def generate(self, depth): raise NotImplementedError
 class BinaryExpression(ExpressionGenerator):
     def __init__(self, op):
         self.op = op
-    def generate(self, depth):  
+    def generate(self, depth):
         exprs = list(MakeExpressionGenerator(depth + 1))
         for x in exprs:
             for y in exprs:
@@ -21,10 +21,10 @@ def generate(self, depth):
 class UnaryExpression(ExpressionGenerator):
     def __init__(self, op):
         self.op = op
-    def generate(self, depth):  
+    def generate(self, depth):
         for x in MakeExpressionGenerator(depth + 1):
             yield self.op + ' ' + x
-                
+
 class EmptyExpression(ExpressionGenerator):
     def generate(self, depth):
         yield ' '
@@ -40,7 +40,7 @@ def __init__(self, value):
         self.value = value
     def generate(self, depth):
         yield self.value
-    
+
 class InvalidExpression(ExpressionGenerator):
     def __init__(self, value):
         self.value = value
@@ -53,16 +53,16 @@ def __init__(self, trailingComma):
     def generate(self, depth):
         subexprs = list(MakeExpressionGenerator(depth + 1))
         head = '('
-        
+
         if self.trailingComma:
             tail = ', )'
         else:
             tail = ')'
-        
+
         args3 = [x + ', ' + y + ', ' + z for x in subexprs for y in subexprs for z in subexprs]
         args2 = [x + ', ' + y for x in subexprs for y in subexprs]
         args1 = [x for x in subexprs]
-        
+
         yield head + tail
         for values in args1 + args2 + args3:
             yield head + values + tail
@@ -75,19 +75,19 @@ def generate(self, depth):
                     yield '(' + expr + ' for ' + target + ' in ' + inTest + ')'
                     for cond in MakeExpressionGenerator(depth + 1):
                         yield '(' + expr + ' for ' + target + ' in ' + inTest + ' if ' + cond + ')'
-                
+
 
 class DictionaryDisplay(ExpressionGenerator):
     def generate(self, depth):
         subexprs = list(MakeExpressionGenerator(depth + 1))
-        
+
         args = [x + ': ' + y for x in subexprs for y in subexprs]
         yield '{}'
-        
+
         for x in args:
             yield '{' + x + '}'
             yield '{' + x + ', }'
-        
+
         for x, y in zip(args, args):
             yield '{' + x + ', ' + y + '}'
             yield '{' + x + ', ' + y + ', }'
@@ -112,52 +112,52 @@ def generate(self, depth):
 class SubscriptionExpression(object):
     def generate(self, depth):
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
                 yield expr + '[' + subscript + ']'
                 yield expr + '[' + subscript + ', ]'
 
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
-                for subscript2 in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
+                for subscript2 in MakeExpressionGenerator(depth + 1):
                     yield expr + '[' + subscript + ', ' + subscript2 + ']'
                     yield expr + '[' + subscript + ', ' + subscript2 + ', ]'
 
 class SlicingExpression(object):
     def generate(self, depth):
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
                 yield expr + '[' + subscript + ':]'
                 #yield expr + '[:' + subscript + ']'
                 #yield expr + '[' + subscript + '::]'
                 #yield expr + '[::' + subscript + ']'
 
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
-                for subscript2 in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
+                for subscript2 in MakeExpressionGenerator(depth + 1):
                     yield expr + '[' + subscript + ': ' + subscript2 + ']'
                     #yield expr + '[' + subscript + ', ' + subscript2 + ': ]'
                     #yield expr + '[ :' + subscript + ', ' + subscript2 + ']'
 
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
-                for subscript2 in MakeExpressionGenerator(depth + 1):            
-                    for subscript3 in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
+                for subscript2 in MakeExpressionGenerator(depth + 1):
+                    for subscript3 in MakeExpressionGenerator(depth + 1):
                         yield expr + '[' + subscript + ': ' + subscript2 + ':' + subscript3 + ']'
 
 class CallExpression(object):
     def generate(self, depth):
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
                 yield expr + '(' + subscript + ')'
                 yield expr + '(' + subscript + ', )'
                 yield expr + '(*' + subscript + ')'
                 yield expr + '(**' + subscript + ', )'
                 for name in MakeExpressionGenerator(depth + 1):
-                    yield expr + '(' + name + ' = ' + subscript + ')'                
+                    yield expr + '(' + name + ' = ' + subscript + ')'
 
         for expr in MakeExpressionGenerator(depth + 1):
-            for subscript in MakeExpressionGenerator(depth + 1):            
-                for subscript2 in MakeExpressionGenerator(depth + 1):            
+            for subscript in MakeExpressionGenerator(depth + 1):
+                for subscript2 in MakeExpressionGenerator(depth + 1):
                     yield expr + '(' + subscript + ', ' + subscript2 + ')'
                     yield expr + '(' + subscript + ', ' + subscript2 + ', )'
                     yield expr + '(*' + subscript + ', ' + subscript2 + ')'
@@ -209,7 +209,7 @@ def generate(self, depth):
 class PassStatement(ExpressionGenerator):
     def generate(self, depth):
         yield 'pass\n'
-    
+
 class IfStatement(ExpressionGenerator):
     def generate(self, depth):
         for expr in MakeExpressionGenerator(0):
@@ -239,21 +239,21 @@ class ExpressionStatement(ExpressionGenerator):
     def generate(self, depth):
         for expr in MakeExpressionGenerator(0):
             yield expr + '\n'
-    
+
 ######################################################################
 # Factories
 
 class BinaryMaker(object):
     def __init__(self, value):
-        self.value = value        
+        self.value = value
     def __call__(self):
         return BinaryExpression(self.value)
     def __repr__(self):
         return 'BinaryMaker(' + repr(self.value) + ')'
 
 class UnaryMaker(object):
     def __init__(self, value):
-        self.value = value        
+        self.value = value
     def __call__(self):
         return UnaryExpression(self.value)
     def __repr__(self):
@@ -291,11 +291,11 @@ def __call__(self):
     def __repr__(self):
         return 'ParenthFormMaker(' + self.trailingComma + ')'
 
-identifier_exprs = [NameMaker('foo'), NameMaker('...'), NameMaker('reallylongname' * 200)] # NameMaker('_bar'), 
+identifier_exprs = [NameMaker('foo'), NameMaker('...'), NameMaker('reallylongname' * 200)] # NameMaker('_bar'),
 
 expr_gens = identifier_exprs + \
-            [BinaryMaker('+'), BinaryMaker('**'), BinaryMaker('<<'), BinaryMaker('&'), BinaryMaker('=='), BinaryMaker('>'), BinaryMaker(' in '),  # BinaryMaker('-'), BinaryMaker('|'), BinaryMaker('^'), 
-             UnaryMaker('~'), UnaryMaker(' not '),  # UnaryMaker('-'), UnaryMaker('+'), 
+            [BinaryMaker('+'), BinaryMaker('**'), BinaryMaker('<<'), BinaryMaker('&'), BinaryMaker('=='), BinaryMaker('>'), BinaryMaker(' in '),  # BinaryMaker('-'), BinaryMaker('|'), BinaryMaker('^'),
+             UnaryMaker('~'), UnaryMaker(' not '),  # UnaryMaker('-'), UnaryMaker('+'),
              EmptyExpression,
              GeneratorExpression,
              DictionaryDisplay,
@@ -304,7 +304,7 @@ def __repr__(self):
              SubscriptionExpression,
              SlicingExpression,
              ConstantMaker(1), ConstantMaker('abc'), ConstantMaker(1), ConstantMaker(1.0), ConstantMaker(1j),
-             ParenthFormMaker(False), ParenthFormMaker(True), 
+             ParenthFormMaker(False), ParenthFormMaker(True),
              StringConversion,
              YieldExpression,
              InvalidMaker('$'), InvalidMaker('@'), InvalidMaker('!'), InvalidMaker('\\'), #InvalidMaker('\0'),
@@ -315,35 +315,35 @@ def __repr__(self):
 
 def MakeExpressionGenerator(depth):
     """yields all possible expressions"""
-    if depth == MAX_DEPTH: 
+    if depth == MAX_DEPTH:
         yield '' # empty expr
-    else: 
-        for exprGen in expr_gens:        
+    else:
+        for exprGen in expr_gens:
             for value in exprGen().generate(depth):
                 yield value
 
 def Indent(value, depth):
-    if depth == 0: 
+    if depth == 0:
         return value
     indent = '    ' * depth
     return indent + value.replace('\n', '\n' + indent)
 
 def MakeStatementGenerator(depth):
     """yields all possible expressions"""
-    if depth == MAX_DEPTH: 
+    if depth == MAX_DEPTH:
         yield '' # empty expr
-    else: 
-        for stmtGen in stmt_gens:        
+    else:
+        for stmtGen in stmt_gens:
             for value in stmtGen().generate(depth):
                 yield Indent(value, depth)
 
 def MakeIdentifierGenerator(depth):
-    for exprGen in identifier_exprs:        
+    for exprGen in identifier_exprs:
         for value in exprGen().generate(depth):
             yield value
-    
+
 i = 0
-for x in MakeStatementGenerator(0):    
+for x in MakeStatementGenerator(0):
     i += 1
     if i % 1000 == 0:
         print('.', end=' ')
@@ -352,4 +352,4 @@ def MakeIdentifierGenerator(depth):
     except SyntaxError:
         pass
 
-print('Ran %d tests', i)
+print('Ran %d tests' % i)

tests/IronPython.Tests/Cases/IronPythonCases.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+
 using NUnit.Framework;
 
 namespace IronPythonTest.Cases {
@@ -18,17 +19,22 @@ public override int Test(TestInfo testcase) {
 
     internal class IronPythonCaseGenerator : CommonCaseGenerator<IronPythonCases> {
         protected override IEnumerable<TestInfo> GetTests() {
-            return GetFilenames(new[] {
-                System.Tuple.Create(category, Path.Combine("tests", "suite")),
-                System.Tuple.Create($"{category}.scripts", Path.Combine("eng", "scripts")),
-            })
-            .OrderBy(testcase => testcase.Name);
+            return GetTestSuite().Concat(GetEngScripts()).OrderBy(testcase => testcase.Name);
+
+            IEnumerable<TestInfo> GetTestSuite() {
+                var root = CaseExecuter.FindRoot();
+                var folder = Path.Combine("tests", "suite");
+                var fullPath = Path.GetFullPath(Path.Combine(root, folder));
+                foreach (var filename in Directory.EnumerateFiles(fullPath, "test_*.py", SearchOption.AllDirectories))
+                    yield return new TestInfo(filename, category, folder, manifest);
+            }
 
-            IEnumerable<TestInfo> GetFilenames(IEnumerable<System.Tuple<string, string>> folders) {
-                foreach (var tuple in folders) {
-                    var fullPath = Path.Combine(CaseExecuter.FindRoot(), tuple.Item2);
-                    foreach (var filename in Directory.EnumerateFiles(fullPath, "test_*.py", SearchOption.AllDirectories))
-                        yield return new TestInfo(Path.GetFullPath(filename), tuple.Item1, tuple.Item2, manifest);
+            IEnumerable<TestInfo> GetEngScripts() {
+                var root = CaseExecuter.FindRoot();
+                var folder = Path.Combine("eng", "scripts");
+                var filename = Path.GetFullPath(Path.Combine(root, folder, "test_cgcheck.py"));
+                if (File.Exists(filename)) {
+                    yield return new TestInfo(filename, $"{category}.scripts", folder, manifest);
                 }
             }
         }

tests/IronPython.Tests/Cases/IronPythonCasesManifest.ini

@@ -36,10 +36,6 @@ MaxRecursion=100
 RunCondition=NOT $(IS_OSX) # TODO: figure out
 IsolationLevel=PROCESS # required to have quit/exit
 
-[IronPython.test_fuzz_parser]
-Ignore=true
-Reason=Takes way too long (ran overnight without completing!)
-
 [IronPython.test_help]
 IsolationLevel=PROCESS # required for help to use pydoc
 
@@ -187,12 +183,3 @@ RunCondition=$(IS_POSIX) # Module resource is Posix-specific
 [IronPython.modules.system_related.test_sys_getframe]
 IsolationLevel=PROCESS # https://github.com/IronLanguages/ironpython3/issues/489
 FullFrames=true
-
-[IronPython.scripts.test_builder]
-Ignore=true
-
-[IronPython.scripts.test_parrot]
-Ignore=true
-
-[IronPython.scripts.test_pystone]
-Ignore=true