Generates a string describing what arguments the double expected.

        :return: A string describing expected arguments.
        :rtype: str
8215
def _expected_argument_string(self):
        

        if self.args is _any and self.kwargs is _any:
            return 'any args'
        elif self._custom_matcher:
            return "custom matcher: '{}'".format(self._custom_matcher.__name__)
        else:
            return build_argument_repr_string(self.args, self.kwargs)
1350453
def _dbg_output(self):
        
        s = "["
        lst = []
        for segment in self._list:
            lst.append(repr(segment))
        s += ", ".join(lst)
        s += "]"
        return s
396021
def randstr(self):
        
        return gen_rand_str(
            2, 10, use=self.random, keyspace=list(self.keyspace))
362760
def on_assert_failed_print_details(actual, expected):
    
    try:
        yield
    except AssertionError:
        # diff = difflib.unified_diff(expected.splitlines(), actual.splitlines(),
        #                            "expected", "actual")
        diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
        diff_text = u"\n".join(diff)
        print(u"DIFF (+ ACTUAL, - EXPECTED):\n{0}\n".format(diff_text))
        if DEBUG:
            print(u"expected:\n{0}\n".format(expected))
            print(u"actual:\n{0}\n".format(actual))
        raise
794651
def args(self) -> str:
        """"""
        return '{}{}{}{}{}{}{}{}{}{}{}'.format(
            to_ascii_hex(self._index, 2),
            to_ascii_hex(self._group_number, 2),
            to_ascii_hex(self._unit_number, 2),
            to_ascii_hex(int(self._enable_status), 4),
            to_ascii_hex(int(self._switches), 4),
            to_ascii_hex(self._current_status, 2),
            to_ascii_hex(self._down_count, 2),
            to_ascii_hex(encode_value_using_ma(self._message_attribute, self._current_reading), 2),
            to_ascii_hex(encode_value_using_ma(self._message_attribute, self._high_limit), 2),
            to_ascii_hex(encode_value_using_ma(self._message_attribute, self._low_limit), 2),
            to_ascii_hex(int(self._special_status), 2))
565281
def get_command_str(args):
    
    single_quote = "'"
    double_quote = '"'
    for i, value in enumerate(args):
        if " " in value and double_quote not in value:
            args[i] = '"%s"' % value
        elif " " in value and single_quote not in value:
            args[i] = "'%s'" % value
    return " ".join(args)
235282
def _parse_arguments():
        
        parser = get_base_arguments(get_parser())
        parser = get_tc_arguments(parser)
        args, unknown = parser.parse_known_args()
        return args, unknown
161634
def argument(self) -> bool:
        
        next = self.peek()
        if next == "'":
            quoted = True
            self.sq_argument()
        elif next == '"':
            quoted = True
            self.dq_argument()
        elif self._arg == "":
            quoted = False
            self.unq_argument()
        else:
            raise UnexpectedInput(self, "single or double quote")
        self.opt_separator()
        next = self.peek()
        if next == ";":
            return False
        if next == "{":
            return True
        elif quoted and next == "+":
            self.offset += 1
            self.opt_separator()
            return self.argument()
        else:
            raise UnexpectedInput(self, "';', '{'" +
                                  (" or '+'" if quoted else ""))
289602
def _normalize_arguments(expr_left, expr_rigth):
    
    if expr_left.is_str_op() and expr_rigth.is_bv_constant():
        return expr_left, Int(expr_rigth.bv_signed_value())
    elif expr_left.is_bv_constant() and expr_rigth.is_str_op():
        return expr_rigth, Int(expr_left.bv_signed_value())
    return expr_left, expr_rigth
291993
def args(self):  # as args tuple
        '''
        '''
        return (self.base, self.item, self.leng, self.refs,
                self.both, self.kind, self.type)
852169
def _var(ins):
    
    output = []
    output.append('%s:' % ins.quad[1])
    output.append('DEFB %s' % ((int(ins.quad[2]) - 1) * '00, ' + '00'))

    return output
745518
def format(self):
        '''
        '''
        c = n = ''
        if not self.both:
            c = ' (code only)'
        if self.leng:
            n = ' (%s)' % _nameof(self.leng)
        return _kwds(base=self.base, item=self.item, leng=n,
                     code=c,         kind=self.kind)
146443
def argnames(self):
        
        # pylint: disable=no-member; github.com/pycqa/astroid/issues/291
        # args is in fact redefined later on by postinit. Can't be changed
        # to None due to a strong interaction between Lambda and FunctionDef.

        if self.args.args:  # maybe None with builtin functions
            names = _rec_get_names(self.args.args)
        else:
            names = []
        if self.args.vararg:
            names.append(self.args.vararg)
        if self.args.kwarg:
            names.append(self.args.kwarg)
        return names
775148
def toString(self):
        
        slist = self.toList()
        string = angle.slistStr(slist)
        return string if slist[0] == '-' else string[1:]
455999
private String getDeltaArgument(VisitorState state, List<Type> argumentTypes) {
    Type firstType = argumentTypes.get(0);
    Type secondType = argumentTypes.get(1);
    boolean doublePrecisionUsed = isDouble(state, firstType) || isDouble(state, secondType);
    return doublePrecisionUsed ? ", 0.0" : ", 0.0f";
  }
332430
def get_args_pairs(arguments):
    

    return ' '.join(' '.join(['-' + k, tcl_str(str(v))]) for k, v in arguments.items())
306930
def _build_evaluation_parameters(self, expectation_args, evaluation_parameters):
        

        evaluation_args = copy.deepcopy(expectation_args)

        # Iterate over arguments, and replace $PARAMETER-defined args with their
        # specified parameters.
        for key, value in evaluation_args.items():
            if isinstance(value, dict) and '$PARAMETER' in value:
                # First, check to see whether an argument was supplied at runtime
                # If it was, use that one, but remove it from the stored config
                if "$PARAMETER." + value["$PARAMETER"] in value:
                    evaluation_args[key] = evaluation_args[key]["$PARAMETER." +
                                                                value["$PARAMETER"]]
                    del expectation_args[key]["$PARAMETER." +
                                              value["$PARAMETER"]]
                elif evaluation_parameters is not None and value["$PARAMETER"] in evaluation_parameters:
                    evaluation_args[key] = evaluation_parameters[value['$PARAMETER']]
                else:
                    raise KeyError(
                        "No value found for $PARAMETER " + value["$PARAMETER"])

        return evaluation_args