libgit2/tests/generate.py at executable · novalis/libgit2 · GitHub

History

267 lines (201 loc) · 8.16 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

#!/usr/bin/env python

# This file is part of clar, distributed under the ISC license.

# For full terms see the included COPYING file.

from __future__ import with_statement

from string import Template

import re, fnmatch, os, sys, codecs, pickle

class Module(object):

class Template(object):

def __init__(self, module):

self.module = module

def _render_callback(self, cb):

if not cb:

return ' { NULL, NULL }'

return ' { "%s", &%s }' % (cb['short_name'], cb['symbol'])

class DeclarationTemplate(Template):

def render(self):

out = "\n".join("extern %s;" % cb['declaration'] for cb in self.module.callbacks) + "\n"

for initializer in self.module.initializers:

out += "extern %s;\n" % initializer['declaration']

if self.module.cleanup:

out += "extern %s;\n" % self.module.cleanup['declaration']

return out

class CallbacksTemplate(Template):

def render(self):

out = "static const struct clar_func _clar_cb_%s[] = {\n" % self.module.name

out += ",\n".join(self._render_callback(cb) for cb in self.module.callbacks)

out += "\n};\n"

return out

class InfoTemplate(Template):

def render(self):

templates = []

initializers = self.module.initializers

if len(initializers) == 0:

initializers = [ None ]

for initializer in initializers:

name = self.module.clean_name()

if initializer and initializer['short_name'].startswith('initialize_'):

variant = initializer['short_name'][len('initialize_'):]

name += " (%s)" % variant.replace('_', ' ')

template = Template(

r"""

{

"${clean_name}",

${initialize},

${cleanup},

${cb_ptr}, ${cb_count}, ${enabled}

}"""

).substitute(

clean_name = name,

initialize = self._render_callback(initializer),

cleanup = self._render_callback(self.module.cleanup),

cb_ptr = "_clar_cb_%s" % self.module.name,

cb_count = len(self.module.callbacks),

enabled = int(self.module.enabled)

)

templates.append(template)

return ','.join(templates)

def __init__(self, name):

self.name = name

self.mtime = 0

self.enabled = True

self.modified = False

def clean_name(self):

return self.name.replace("_", "::")

def _skip_comments(self, text):

SKIP_COMMENTS_REGEX = re.compile(

r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"',

re.DOTALL | re.MULTILINE)

def _replacer(match):

s = match.group(0)

return "" if s.startswith('/') else s

return re.sub(SKIP_COMMENTS_REGEX, _replacer, text)

def parse(self, contents):

TEST_FUNC_REGEX = r"^(void\s+(test_%s__(\w+))\s*$\s*void\s*$)\s*\{"

contents = self._skip_comments(contents)

regex = re.compile(TEST_FUNC_REGEX % self.name, re.MULTILINE)

self.callbacks = []

self.initializers = []

self.cleanup = None

for (declaration, symbol, short_name) in regex.findall(contents):

data = {

"short_name" : short_name,

"declaration" : declaration,

"symbol" : symbol

}

if short_name.startswith('initialize'):

self.initializers.append(data)

elif short_name == 'cleanup':

self.cleanup = data

else:

self.callbacks.append(data)

return self.callbacks != []

def refresh(self, path):

self.modified = False

try:

st = os.stat(path)

# Not modified

if st.st_mtime == self.mtime:

return True

self.modified = True

self.mtime = st.st_mtime

with codecs.open(path, encoding='utf-8') as fp:

raw_content = fp.read()

except IOError:

return False

return self.parse(raw_content)

class TestSuite(object):

def __init__(self, path, output):

self.path = path

self.output = output

def should_generate(self, path):

if not os.path.isfile(path):

return True

if any(module.modified for module in self.modules.values()):

return True

return False

def find_modules(self):

modules = []

for root, _, files in os.walk(self.path):

module_root = root[len(self.path):]

module_root = [c for c in module_root.split(os.sep) if c]

tests_in_module = fnmatch.filter(files, "*.c")

for test_file in tests_in_module:

full_path = os.path.join(root, test_file)

module_name = "_".join(module_root + [test_file[:-2]]).replace("-", "_")

modules.append((full_path, module_name))

return modules

def load_cache(self):

path = os.path.join(self.output, '.clarcache')

cache = {}

try:

fp = open(path, 'rb')

cache = pickle.load(fp)

fp.close()

except (IOError, ValueError):

pass

return cache

def save_cache(self):

path = os.path.join(self.output, '.clarcache')

with open(path, 'wb') as cache:

pickle.dump(self.modules, cache)

def load(self, force = False):

module_data = self.find_modules()

self.modules = {} if force else self.load_cache()

for path, name in module_data:

if name not in self.modules:

self.modules[name] = Module(name)

if not self.modules[name].refresh(path):

del self.modules[name]

def disable(self, excluded):

for exclude in excluded:

for module in self.modules.values():

name = module.clean_name()

if name.startswith(exclude):

module.enabled = False

module.modified = True

def suite_count(self):

return sum(max(1, len(m.initializers)) for m in self.modules.values())

def callback_count(self):

return sum(len(module.callbacks) for module in self.modules.values())

def write(self):

output = os.path.join(self.output, 'clar.suite')

if not self.should_generate(output):

return False

with open(output, 'w') as data:

modules = sorted(self.modules.values(), key=lambda module: module.name)

for module in modules:

t = Module.DeclarationTemplate(module)

data.write(t.render())

for module in modules:

t = Module.CallbacksTemplate(module)

data.write(t.render())

suites = "static struct clar_suite _clar_suites[] = {" + ','.join(

Module.InfoTemplate(module).render() for module in modules

) + "\n};\n"

data.write(suites)

data.write("static const size_t _clar_suite_count = %d;\n" % self.suite_count())

data.write("static const size_t _clar_callback_count = %d;\n" % self.callback_count())

self.save_cache()

return True

if __name__ == '__main__':

from optparse import OptionParser

parser = OptionParser()

parser.add_option('-f', '--force', action="store_true", dest='force', default=False)

parser.add_option('-x', '--exclude', dest='excluded', action='append', default=[])

parser.add_option('-o', '--output', dest='output')

options, args = parser.parse_args()

if len(args) > 1:

print("More than one path given")

sys.exit(1)

path = args.pop() if args else '.'

output = options.output or path

suite = TestSuite(path, output)

suite.load(options.force)

suite.disable(options.excluded)

if suite.write():

print("Written `clar.suite` (%d tests in %d suites)" % (suite.callback_count(), suite.suite_count()))

libgit2/tests/generate.py at executable · novalis/libgit2 · GitHub

Expand file tree

Breadcrumbs

generate.py

Latest commit

History

Breadcrumbs

generate.py

File metadata and controls