build_report = {}
    build_properties = {}

    platforms = None
    if options.platforms != "":
        platforms = set(options.platforms.split(","))

    if options.build_tests:
        # Get all paths
        directories = options.build_tests.split(',')
        for i in range(len(directories)):
            directories[i] = normpath(join(TEST_DIR, directories[i]))

        test_names = []

        for test_id in TEST_MAP.keys():
            # Prevents tests with multiple source dirs from being checked
            if isinstance( TEST_MAP[test_id].source_dir, basestring):
                test_path = normpath(TEST_MAP[test_id].source_dir)
                for directory in directories:
                    if directory in test_path:
                        test_names.append(test_id)

        mut_counter = 1
        mut = {}
        test_spec = {
            "targets": {}
        }

        for target_name, toolchain_list in OFFICIAL_MBED_LIBRARY_BUILD:
            toolchains = None

                      default=False, help="List available tests in order and exit")

    # Ideally, all the tests with a single "main" thread can be run with, or
    # without the rtos
    parser.add_option("--rtos", action="store_true", dest="rtos",
                      default=False, help="Link to the rtos")

    # Specify a different linker script
    parser.add_option("-l", "--linker", dest="linker_script",
                      default=None, help="use the specified linker script")

    (options, args) = parser.parse_args()

    # Print available tests in order and exit
    if options.list_tests is True:
        print '\n'.join(map(str, sorted(TEST_MAP.values())))
        sys.exit()

    # force program to "0" if a source dir is specified
    if options.source_dir is not None:
        p = 0
        n = None
    else:
    # Program Number or name
        p, n = options.program, options.program_name

    if n is not None and p is not None:
        args_error(parser, "[ERROR] specify either '-n' or '-p', not both")
    if n:
        if not n in TEST_MAP.keys():
            # Check if there is an alias for this in private_settings.py

            # print '=== %s::%s ===' % (target, toolchain)
            # Let's build our test
            if target not in TARGET_MAP:
                print 'Skipped tests for %s target. Target platform not found' % (target)
                continue

            T = TARGET_MAP[target]
            build_mbed_libs_options = ["analyze"] if opts.goanna_for_mbed_sdk else None
            build_mbed_libs_result = build_mbed_libs(T, toolchain, options=build_mbed_libs_options)
            if not build_mbed_libs_result:
                print 'Skipped tests for %s target. Toolchain %s is not yet supported for this target' % (T.name, toolchain)
                continue

            build_dir = join(BUILD_DIR, "test", target, toolchain)

            for test_id, test in TEST_MAP.iteritems():
                if opts.test_by_names and test_id not in opts.test_by_names.split(','):
                    continue

                if test_ids and test_id not in test_ids:
                    continue

                if opts.test_only_peripheral and not test.peripherals:
                    if opts.verbose_skipped_tests:
                        print "TargetTest::%s::NotPeripheralTestSkipped()" % (target)
                    continue

                if opts.test_only_common and test.peripherals:
                    if opts.verbose_skipped_tests:
                        print "TargetTest::%s::PeripheralTestSkipped()" % (target)
                    continue

                   default=None, help="The mbed serial port")
 parser.add_option("-b", "--baud", type="int", dest="baud",
                   default=None, help="The mbed serial baud rate")
 
 # Ideally, all the tests with a single "main" thread can be run with, or
 # without the rtos
 parser.add_option("--rtos", action="store_true", dest="rtos",
                   default=False, help="Link to the rtos")
 
 (options, args) = parser.parse_args()
 
 # Program Number
 p = options.program
 if p is None or (p < 0) or (p > (len(TESTS)-1)):
     message = "[ERROR] You have to specify one of the following tests:\n"
     descriptions = [(test.n, test.description) for test in TEST_MAP.values()]
     descriptions.sort()
     message += '\n'.join(["  [%2d] %s " % d for d in descriptions])
     args_error(parser, message)
 
 # Target
 if options.mcu is None :
     args_error(parser, "[ERROR] You should specify an MCU")
 mcu = options.mcu
 
 # Toolchain
 if options.tool is None:
     args_error(parser, "[ERROR] You should specify a TOOLCHAIN")
 toolchain = options.tool
 
 # Test

            # Let's build our test
            if target not in TARGET_MAP:
                print 'Skipped tests for %s target. Target platform not found' % (target)
                continue

            T = TARGET_MAP[target]
            build_mbed_libs_options = ["analyze"] if opts.goanna_for_mbed_sdk else None
            build_mbed_libs_result = build_mbed_libs(T, toolchain, options=build_mbed_libs_options)
            if not build_mbed_libs_result:
                print 'Skipped tests for %s target. Toolchain %s is not yet supported for this target' % (T.name, toolchain)
                continue

            build_dir = join(BUILD_DIR, "test", target, toolchain)

            # Enumerate through all tests
            test_map_keys = TEST_MAP.keys()
            if opts.shuffle_test_order:
                random.shuffle(test_map_keys)

            for test_id in test_map_keys:
                test = TEST_MAP[test_id]
                if opts.test_by_names and test_id not in opts.test_by_names.split(','):
                    continue

                if test_ids and test_id not in test_ids:
                    continue

                if opts.test_only_peripheral and not test.peripherals:
                    if opts.verbose_skipped_tests:
                        print "TargetTest::%s::NotPeripheralTestSkipped()" % (target)
                    continue

    parser.add_option("--testlib",
                      action="store_true",
                      dest="testlib",
                      default=False,
                      help="Link with mbed test library")

    # Specify a different linker script
    parser.add_option("-l", "--linker", dest="linker_script",
                      default=None, help="use the specified linker script")

    (options, args) = parser.parse_args()

    # Print available tests in order and exit
    if options.list_tests is True:
        print '\n'.join(map(str, sorted(TEST_MAP.values())))
        sys.exit()

    # force program to "0" if a source dir is specified
    if options.source_dir is not None:
        p = 0
        n = None
    else:
    # Program Number or name
        p, n = options.program, options.program_name

    if n is not None and p is not None:
        args_error(parser, "[ERROR] specify either '-n' or '-p', not both")
    if n:
        # We will transform 'n' to list of 'p' (integers which are test numbers)
        nlist = n.split(',')

 (options, args) = parser.parse_args()
 
 # Target
 if options.mcu is None :
     args_error(parser, "[ERROR] You should specify an MCU")
 mcu = options.mcu
 
 # IDE
 if options.ide is None:
     args_error(parser, "[ERROR] You should specify an IDE")
 ide = options.ide
 
 # Project
 if options.program is None or (options.program < 0) or (options.program > (len(TESTS)-1)):
     message = "[ERROR] You have to specify one of the following tests:\n"
     message += '\n'.join(map(str, sorted(TEST_MAP.values())))
     args_error(parser, message)
 test = Test(options.program)
 
 if not options.build:
     # Substitute the library builds with the sources
     # TODO: Substitute also the other library build paths
     if MBED_LIBRARIES in test.dependencies:
         test.dependencies.remove(MBED_LIBRARIES)
         test.dependencies.append(MBED_BASE)
 
 # Build the projectwith the same directory structure of the mbed online IDE
 project_dir = join(EXPORT_WORKSPACE, test.id)
 setup_user_prj(project_dir, test.source_dir, test.dependencies)
 
 # Export to selected toolchain 

    (options, args) = parser.parse_args()

    # Target
    if options.mcu is None:
        args_error(parser, "[ERROR] You should specify an MCU")
    mcu = options.mcu

    # IDE
    if options.ide is None:
        args_error(parser, "[ERROR] You should specify an IDE")
    ide = options.ide

    # Project
    if options.program is None or (options.program < 0) or (options.program > (len(TESTS) - 1)):
        message = "[ERROR] You have to specify one of the following tests:\n"
        message += "\n".join(map(str, sorted(TEST_MAP.values())))
        args_error(parser, message)
    test = Test(options.program)

    if not options.build:
        # Substitute the library builds with the sources
        # TODO: Substitute also the other library build paths
        if MBED_LIBRARIES in test.dependencies:
            test.dependencies.remove(MBED_LIBRARIES)
            test.dependencies.append(MBED_BASE)

    # Build the projectwith the same directory structure of the mbed online IDE
    project_dir = join(EXPORT_WORKSPACE, test.id)
    setup_user_prj(project_dir, test.source_dir, test.dependencies)

    # Export to selected toolchain