Amount of skipped test cases in this list.

        :return: integer
422333
def skip_count(self):
        
        return len([i for i, result in enumerate(self.data) if result.skip])
597260
def countok(self):
        
        ok = np.ones(len(self.stars)).astype(bool)
        for name in self.constraints:
            c = self.constraints[name]
            if c.name not in self.selectfrac_skip:
                ok &= c.ok
        return ok
79905
@Override
    public int countMissing() {
        int count = 0;
        for (int i = 0; i < size(); i++) {
            if (TextColumnType.missingValueIndicator().equals(get(i))) {
                count++;
            }
        }
        return count;
    }
633072
@Override
    public int countMissing() {
        int count = 0;
        for (int i = 0; i < size(); i++) {
            if (getIntInternal(i) == TimeColumnType.missingValueIndicator()) {
                count++;
            }
        }
        return count;
    }
332827
def error_count(self):
        """"""
        count = 0
        for error_list in self.error_dict.values():
            count += len(error_list)
        return count
296753
def get_ok_results(self, verbose=True):
        
        if len(self.trials) == 0:
            return []

        not_ok = np.where(np.array(self.statuses()) != "ok")[0]

        if len(not_ok) > 0 and verbose:
            print("{0}/{1} trials were not ok.".format(len(not_ok), len(self.trials)))
            print("Trials: " + str(not_ok))
            print("Statuses: " + str(np.array(self.statuses())[not_ok]))

        r = [merge_dicts({"tid": t["tid"]}, t["result"].to_dict())
             for t in self.trials if t["result"]["status"] == "ok"]
        return r
122977
def missed_statements(self, filename):
        
        el = self._get_class_element_by_filename(filename)
        lines = el.xpath('./lines/line[@hits=0]')
        return [int(l.attrib['number']) for l in lines]
491492
def sweep(self):
        
        self.preSweep()
        if self.loadOrder == []:
            raise NetworkError('No loadOrder for the inputs. Make sure inputs are properly set.', self.loadOrder)
        if len(self.targets) != 0 and len(self.targets) != len(self.inputs):
            raise NetworkError("Number of inputs does not equal number of targets (inputs=%d, targets=%d)" % (len(self.targets), len(self.inputs)))
        if self.verbosity >= 1: print("Epoch #", self.epoch, "Cycle...")
        if not self.orderedInputs:
            self.randomizeOrder()
        tssError = 0.0; totalCorrect = 0; totalCount = 0; totalPCorrect = {}
        cnt = 0
        if self.saveResults:
            self.results = [(0,0,0) for x in self.loadOrder]
        for i in self.loadOrder:
            if self.verbosity >= 1 or self.interactive:
                print("-----------------------------------Pattern #", self.loadOrder[i] + 1)
            datum = self.getData(i) # creates a dictionary of input/targets from self.inputs, self.targets
            if cnt < len(self.loadOrder) - 1:
                self.currentSweepCount = cnt
            else:
                self.currentSweepCount = None
            self._sweeping = 1
            (error, correct, total, pcorrect) = self.step( **datum )
            self._sweeping = 0
            if self.saveResults:
                self.results[i] = (error, correct, total, pcorrect)
            tssError += error
            totalCorrect += correct
            totalCount += total
            sumMerge(totalPCorrect, pcorrect)
            if self.sweepReportRate and (cnt + 1) % self.sweepReportRate == 0:
                print("   Step # %6d | TSS Error: %.4f | Correct: %.4f" % \
                      (cnt + 1, tssError, totalCorrect * 1.0 / totalCount))
            if self.crossValidationSampleRate and self.epoch % self.crossValidationSampleRate == 0:
                self.saveNetworkForCrossValidation(self.crossValidationSampleFile)
            cnt += 1
        if self.learning and self.batch:
            self.change_weights() # batch mode, otherwise change weights in step
        self.postSweep()
        return (tssError, totalCorrect, totalCount, totalPCorrect)
48867
def coverage(self):
        
        variant_start_index, variant_end_index = self.variant_indices()
        n_nucleotides = len(self)
        coverage_array = np.zeros(n_nucleotides, dtype="int32")
        for read in self.reads:
            coverage_array[
                max(0, variant_start_index - len(read.prefix)):
                min(n_nucleotides, variant_end_index + len(read.suffix))] += 1
        return coverage_array
1366134
public String skipped()
    {
        int start = 0;
        if (stack.size() > 1)
        {
            start = stack.get(stack.size() - 2).end();
        }
        int end = stack.get(stack.size() - 1).start();
        return text.subSequence(start, end).toString();
    }
111150
public synchronized int skip(int count) {
        if (count > available) {
            count = available;
        }
        idxGet = (idxGet + count) % capacity;
        available -= count;
        return count;
    }
1279346
def _get_checks(self, checkclass, skip_checks):
        
        meths = inspect.getmembers(checkclass, inspect.ismethod)
        # return all check methods not among the skipped checks
        returned_checks = []
        for fn_name, fn_obj in meths:
            if (fn_name.startswith("check_") and
                skip_checks[fn_name] != BaseCheck.HIGH):
                returned_checks.append((fn_obj, skip_checks[fn_name]))

        return returned_checks
1201263
def one(self):
        ''' 
        '''
        count = -1
        for count, result in enumerate(self):
            if count > 0:
                raise BadResultException('Too many results for .one()')
        if count == -1:
            raise BadResultException('Too few results for .one()')
        return result
106729
def element_count(self):
        
        result = conf.lib.clang_getNumElements(self)
        if result < 0:
            raise Exception('Type does not have elements.')

        return result
1029018
def get_min_context_count(self,context_type):
    
    cnt = 10000000000
    bases = ['A','C','G','T']
    basesplus = ['A','C','G','T','-']
    r = None
    if context_type == 'target':
      r = self.get_target_context_errors()
    elif context_type == 'query':
      r = self.get_query_context_errors()
    else:
      sys.stderr.write("ERROR incorrect context type\n")
      sys.exit()
    for b1 in bases:
      for b2 in bases:
        for b3 in basesplus:
          if r[b1][b2][b3]['total'] < cnt: cnt = r[b1][b2][b3]['total']
    return cnt
904144
def _generate_out_list(results):
    '''
    
    '''
    passed = 0
    failed = 0
    skipped = 0
    missing_tests = 0
    total_time = 0.0
    for state in results:
        if not results[state].items():
            missing_tests = missing_tests + 1
        else:
            for dummy, val in results[state].items():
                log.info("dummy=%s, val=%s", dummy, val)
                if val['status'].startswith('Pass'):
                    passed = passed + 1
                if val['status'].startswith('Fail'):
                    failed = failed + 1
                if val['status'].startswith('Skip'):
                    skipped = skipped + 1
                total_time = total_time + float(val['duration'])
    out_list = []
    for key, value in results.items():
        out_list.append({key: value})
    out_list.sort()
    out_list.append({'TEST RESULTS': {'Execution Time': round(total_time, 4),
                                      'Passed': passed, 'Failed': failed, 'Skipped': skipped,
                                      'Missing Tests': missing_tests}})
    return out_list
964176
public void used( final TestCaseDef testCase)
    {
    // Note: must accumulate tuples into a separate list to avoid ConcurrentModificationException when updating used/unused membership.
    List<Tuple> usedTuples =
      IteratorUtils.toList(
        IteratorUtils.filteredIterator(
          IteratorUtils.chainedIterator(
            unused_.iterator(),
            used_.iterator()),
          tuple -> testCase.usesTuple( tuple)));

    for( Tuple tuple : usedTuples)
      {
      used( tuple);
      }
    }