tests/site_scons/site_init.py

   1 import subprocess
   2 import sys
   3 import re
   4
   5 try:
   6     # Make terminal colors work on windows
   7     import colorama
   8     colorama.init()
   9 except ImportError:
  10     pass
  11
  12 def add_nanopb_builders(env):
  13     '''Add the necessary builder commands for nanopb tests.'''
  14
  15     # Build command for building .pb from .proto using protoc
  16     def proto_actions(source, target, env, for_signature):
  17         esc = env['ESCAPE']
  18         dirs = ' '.join(['-I' + esc(env.GetBuildPath(d)) for d in env['PROTOCPATH']])
  19         return '$PROTOC $PROTOCFLAGS %s -o%s %s' % (dirs, esc(str(target[0])), esc(str(source[0])))
  20
  21     proto_file_builder = Builder(generator = proto_actions,
  22                                  suffix = '.pb',
  23                                  src_suffix = '.proto')
  24     env.Append(BUILDERS = {'Proto': proto_file_builder})
  25     env.SetDefault(PROTOC = 'protoc')
  26     env.SetDefault(PROTOCPATH = ['.'])
  27
  28     # Build command for running nanopb generator
  29     import os.path
  30     def nanopb_targets(target, source, env):
  31         basename = os.path.splitext(str(source[0]))[0]
  32         target.append(basename + '.pb.h')
  33         return target, source
  34
  35     nanopb_file_builder = Builder(action = '$NANOPB_GENERATOR $NANOPB_FLAGS $SOURCE',
  36                                   suffix = '.pb.c',
  37                                   src_suffix = '.pb',
  38                                   emitter = nanopb_targets)
  39     env.Append(BUILDERS = {'Nanopb': nanopb_file_builder})
  40     gen_path = env['ESCAPE'](env.GetBuildPath("#../generator/nanopb_generator.py"))
  41     env.SetDefault(NANOPB_GENERATOR = 'python ' + gen_path)
  42     env.SetDefault(NANOPB_FLAGS = '-q')
  43
  44     # Combined method to run both protoc and nanopb generator
  45     def run_protoc_and_nanopb(env, source):
  46         b1 = env.Proto(source)
  47         b2 = env.Nanopb(source)
  48         return b1 + b2
  49     env.AddMethod(run_protoc_and_nanopb, "NanopbProto")
  50
  51     # Build command that runs a test program and saves the output
  52     def run_test(target, source, env):
  53         if len(source) > 1:
  54             infile = open(str(source[1]))
  55         else:
  56             infile = None
  57
  58         args = [str(source[0])]
  59         if env.has_key('ARGS'):
  60             args.extend(env['ARGS'])
  61
  62         pipe = subprocess.Popen(args,
  63                                 stdin = infile,
  64                                 stdout = open(str(target[0]), 'w'),
  65                                 stderr = sys.stderr)
  66         result = pipe.wait()
  67         if result == 0:
  68             print '\033[32m[ OK ]\033[0m   Ran ' + str(source[0])
  69         else:
  70             print '\033[31m[FAIL]\033[0m   Program ' + str(source[0]) + ' returned ' + str(result)
  71         return result
  72
  73     run_test_builder = Builder(action = run_test,
  74                                suffix = '.output')
  75     env.Append(BUILDERS = {'RunTest': run_test_builder})
  76
  77     # Build command that decodes a message using protoc
  78     def decode_actions(source, target, env, for_signature):
  79         esc = env['ESCAPE']
  80         dirs = ' '.join(['-I' + esc(env.GetBuildPath(d)) for d in env['PROTOCPATH']])
  81         return '$PROTOC $PROTOCFLAGS %s --decode=%s %s <%s >%s' % (
  82             dirs, env['MESSAGE'], esc(str(source[1])), esc(str(source[0])), esc(str(target[0])))
  83
  84     decode_builder = Builder(generator = decode_actions,
  85                              suffix = '.decoded')
  86     env.Append(BUILDERS = {'Decode': decode_builder})
  87
  88     # Build command that encodes a message using protoc
  89     def encode_actions(source, target, env, for_signature):
  90         esc = env['ESCAPE']
  91         dirs = ' '.join(['-I' + esc(env.GetBuildPath(d)) for d in env['PROTOCPATH']])
  92         return '$PROTOC $PROTOCFLAGS %s --encode=%s %s <%s >%s' % (
  93             dirs, env['MESSAGE'], esc(str(source[1])), esc(str(source[0])), esc(str(target[0])))
  94
  95     encode_builder = Builder(generator = encode_actions,
  96                              suffix = '.encoded')
  97     env.Append(BUILDERS = {'Encode': encode_builder})
  98
  99     # Build command that asserts that two files be equal
 100     def compare_files(target, source, env):
 101         data1 = open(str(source[0]), 'rb').read()
 102         data2 = open(str(source[1]), 'rb').read()
 103         if data1 == data2:
 104             print '\033[32m[ OK ]\033[0m   Files equal: ' + str(source[0]) + ' and ' + str(source[1])
 105             return 0
 106         else:
 107             print '\033[31m[FAIL]\033[0m   Files differ: ' + str(source[0]) + ' and ' + str(source[1])
 108             return 1
 109
 110     compare_builder = Builder(action = compare_files,
 111                               suffix = '.equal')
 112     env.Append(BUILDERS = {'Compare': compare_builder})
 113
 114     # Build command that checks that each pattern in source2 is found in source1.
 115     def match_files(target, source, env):
 116         data = open(str(source[0]), 'rU').read()
 117         patterns = open(str(source[1]))
 118         for pattern in patterns:
 119             if pattern.strip() and not re.search(pattern.strip(), data, re.MULTILINE):
 120                 print '\033[31m[FAIL]\033[0m   Pattern not found in ' + str(source[0]) + ': ' + pattern
 121                 return 1
 122         else:
 123             print '\033[32m[ OK ]\033[0m   All patterns found in ' + str(source[0])
 124             return 0
 125
 126     match_builder = Builder(action = match_files, suffix = '.matched')
 127     env.Append(BUILDERS = {'Match': match_builder})
 128
 129