testcfg.py 6.12 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
# Copyright 2011 the V8 project authors. All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
#       notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
#       copyright notice, this list of conditions and the following
#       disclaimer in the documentation and/or other materials provided
#       with the distribution.
#     * Neither the name of Google Inc. nor the names of its
#       contributors may be used to endorse or promote products derived
#       from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import test
import os
30
from os.path import join, dirname, exists, isfile
31 32
import platform
import utils
33
import re
34 35 36

class PreparserTestCase(test.TestCase):

37
  def __init__(self, root, path, executable, mode, throws, context, source):
38 39 40
    super(PreparserTestCase, self).__init__(context, path, mode)
    self.executable = executable
    self.root = root
41
    self.throws = throws
42
    self.source = source
43 44 45 46 47 48 49

  def GetLabel(self):
    return "%s %s %s" % (self.mode, self.path[-2], self.path[-1])

  def GetName(self):
    return self.path[-1]

50 51 52 53 54 55
  def HasSource(self):
    return self.source is not None

  def GetSource():
    return self.source

56
  def BuildCommand(self, path):
57 58 59 60 61
    if (self.source is not None):
      result = [self.executable, "-e", self.source]
    else:
      testfile = join(self.root, self.GetName()) + ".js"
      result = [self.executable, testfile]
62 63
    if (self.throws):
      result += ['throws'] + self.throws
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
    return result

  def GetCommand(self):
    return self.BuildCommand(self.path)

  def Run(self):
    return test.TestCase.Run(self)


class PreparserTestConfiguration(test.TestConfiguration):

  def __init__(self, context, root):
    super(PreparserTestConfiguration, self).__init__(context, root)

  def GetBuildRequirements(self):
    return ['preparser']

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
  def GetExpectations(self):
    expects_file = join(self.root, 'preparser.expectation')
    map = {}
    if exists(expects_file):
      rule_regex = re.compile("^([\w\-]+)(?::([\w\-]+))?(?::(\d+),(\d+))?$")
      for line in utils.ReadLinesFrom(expects_file):
        if (line[0] == '#'): continue
        rule_match = rule_regex.match(line)
        if rule_match:
          expects = []
          if (rule_match.group(2)):
            expects = expects + [rule_match.group(2)]
            if (rule_match.group(3)):
              expects = expects + [rule_match.group(3), rule_match.group(4)]
          map[rule_match.group(1)] = expects
    return map;

98 99 100 101 102 103 104 105 106 107
  def ParsePythonTestTemplates(self, result, filename,
                               executable, current_path, mode):
    pathname = join(self.root, filename + ".pyt")
    def Test(name, source, expectation):
      throws = None
      if (expectation is not None):
        throws = [expectation]
      test = PreparserTestCase(self.root,
                               current_path + [filename, name],
                               executable,
108 109
                               mode, throws, self.context,
                               source.replace("\n", " "))
110 111 112 113 114 115 116 117 118 119
      result.append(test)
    def Template(name, source):
      def MkTest(replacement, expectation):
        testname = name
        testsource = source
        for key in replacement.keys():
          testname = testname.replace("$"+key, replacement[key]);
          testsource = testsource.replace("$"+key, replacement[key]);
        Test(testname, testsource, expectation)
      return MkTest
120
    execfile(pathname, {"Test": Test, "Template": Template})
121

122
  def ListTests(self, current_path, path, mode, variant_flags):
123
    executable = 'preparser'
124 125 126
    if utils.IsWindows():
      executable += '.exe'
    executable = join(self.context.buildspace, executable)
127 128 129 130 131
    if not isfile(executable):
      executable = join('obj', 'preparser', mode, 'preparser')
      if utils.IsWindows():
        executable += '.exe'
      executable = join(self.context.buildspace, executable)
132
    expectations = self.GetExpectations()
133
    result = []
134 135 136 137
    # Find all .js files in tests/preparser directory.
    filenames = [f[:-3] for f in os.listdir(self.root) if f.endswith(".js")]
    filenames.sort()
    for file in filenames:
138 139 140
      throws = None;
      if (file in expectations):
        throws = expectations[file]
141 142
      result.append(PreparserTestCase(self.root,
                                      current_path + [file], executable,
143 144 145 146 147 148
                                      mode, throws, self.context, None))
    # Find all .pyt files in test/preparser directory.
    filenames = [f[:-4] for f in os.listdir(self.root) if f.endswith(".pyt")]
    filenames.sort()
    for file in filenames:
      # Each file as a python source file to be executed in a specially
149
      # created environment (defining the Template and Test functions)
150
      self.ParsePythonTestTemplates(result, file,
lrn@chromium.org's avatar
lrn@chromium.org committed
151
                                    executable, current_path, mode)
152 153 154 155 156 157 158
    return result

  def GetTestStatus(self, sections, defs):
    status_file = join(self.root, 'preparser.status')
    if exists(status_file):
      test.ReadConfigurationInto(status_file, sections, defs)

159 160 161
  def VariantFlags(self):
    return [[]];

162 163 164

def GetConfiguration(context, root):
  return PreparserTestConfiguration(context, root)