SYMBOL INDEX (2557 symbols across 226 files)

FILE: examples/cifar10/convert_cifar_data.cpp
  function read_image (line 30) | void read_image(std::ifstream* file, int* label, char* buffer) {
  function convert_dataset (line 38) | void convert_dataset(const string& input_folder, const string& output_fo...
  function main (line 94) | int main(int argc, char** argv) {

FILE: examples/cpp_classification/classification.cpp
  class Classifier (line 18) | class Classifier {
  function PairCompare (line 83) | static bool PairCompare(const std::pair<float, int>& lhs,
  function Argmax (line 89) | static std::vector<int> Argmax(const std::vector<float>& v, int N) {
  function main (line 226) | int main(int argc, char** argv) {

FILE: examples/finetune_flickr_style/assemble_data.py
  function download_image (line 23) | def download_image(args_tuple):

FILE: examples/mnist/convert_mnist_data.cpp
  function swap_endian (line 28) | uint32_t swap_endian(uint32_t val) {
  function convert_dataset (line 33) | void convert_dataset(const char* image_filename, const char* label_filen...
  function main (line 172) | int main(int argc, char** argv) {

FILE: examples/pycaffe/caffenet.py
  function conv_relu (line 7) | def conv_relu(bottom, ks, nout, stride=1, pad=0, group=1):
  function fc_relu (line 12) | def fc_relu(bottom, nout):
  function max_pool (line 16) | def max_pool(bottom, ks, stride=1):
  function caffenet (line 19) | def caffenet(lmdb, batch_size=256, include_acc=False):
  function make_net (line 47) | def make_net():

FILE: examples/pycaffe/layers/pyloss.py
  class EuclideanLossLayer (line 5) | class EuclideanLossLayer(caffe.Layer):
    method setup (line 11) | def setup(self, bottom, top):
    method reshape (line 16) | def reshape(self, bottom, top):
    method forward (line 25) | def forward(self, bottom, top):
    method backward (line 29) | def backward(self, top, propagate_down, bottom):

FILE: examples/siamese/convert_mnist_siamese_data.cpp
  function swap_endian (line 19) | uint32_t swap_endian(uint32_t val) {
  function read_image (line 24) | void read_image(std::ifstream* image_file, std::ifstream* label_file,
  function convert_dataset (line 33) | void convert_dataset(const char* image_filename, const char* label_filen...
  function main (line 108) | int main(int argc, char** argv) {

FILE: examples/web_demo/app.py
  function index (line 29) | def index():
  function classify_url (line 34) | def classify_url():
  function classify_upload (line 57) | def classify_upload():
  function embed_image_html (line 82) | def embed_image_html(image):
  function allowed_file (line 92) | def allowed_file(filename):
  class ImagenetClassifier (line 99) | class ImagenetClassifier(object):
    method __init__ (line 119) | def __init__(self, model_def_file, pretrained_model_file, mean_file,
    method classify_image (line 148) | def classify_image(self, image):
  function start_tornado (line 184) | def start_tornado(app, port=5000):
  function start_from_terminal (line 192) | def start_from_terminal(app):

FILE: examples/web_demo/exifutil.py
  function open_oriented_im (line 19) | def open_oriented_im(im_path):
  function apply_orientation (line 35) | def apply_orientation(im, orientation):

FILE: include/caffe/blob.hpp
  type caffe (line 15) | namespace caffe {
    class Blob (line 25) | class Blob {
      method Blob (line 27) | Blob()
      method string (line 55) | inline string shape_string() const {
      method shape (line 72) | inline int shape(int index) const {
      method num_axes (line 75) | inline int num_axes() const { return shape_.size(); }
      method count (line 76) | inline int count() const { return count_; }
      method count (line 86) | inline int count(int start_axis, int end_axis) const {
      method count (line 104) | inline int count(int start_axis) const {
      method CanonicalAxisIndex (line 119) | inline int CanonicalAxisIndex(int axis_index) const {
      method num (line 133) | inline int num() const { return LegacyShape(0); }
      method channels (line 135) | inline int channels() const { return LegacyShape(1); }
      method height (line 137) | inline int height() const { return LegacyShape(2); }
      method width (line 139) | inline int width() const { return LegacyShape(3); }
      method LegacyShape (line 140) | inline int LegacyShape(int index) const {
      method offset (line 154) | inline int offset(const int n, const int c = 0, const int h = 0,
      method offset (line 167) | inline int offset(const vector<int>& indices) const {
      method Dtype (line 192) | inline Dtype data_at(const int n, const int c, const int h,
      method Dtype (line 197) | inline Dtype diff_at(const int n, const int c, const int h,
      method Dtype (line 202) | inline Dtype data_at(const vector<int>& index) const {
      method Dtype (line 206) | inline Dtype diff_at(const vector<int>& index) const {

FILE: include/caffe/common.hpp
  type cv (line 69) | namespace cv { class Mat; }
    class Mat (line 69) | class Mat
  type caffe (line 71) | namespace caffe {
    class Caffe (line 98) | class Caffe {
      type Brew (line 107) | enum Brew { CPU, GPU }
      class RNG (line 111) | class RNG {
        class Generator (line 119) | class Generator
      method RNG (line 124) | inline static RNG& rng_stream() {
        class Generator (line 119) | class Generator
      method cublasHandle_t (line 131) | inline static cublasHandle_t cublas_handle() { return Get().cublas_h...
      method curandGenerator_t (line 132) | inline static curandGenerator_t curand_generator() {
      method Brew (line 138) | inline static Brew mode() { return Get().mode_; }
      method set_mode (line 144) | inline static void set_mode(Brew mode) { Get().mode_ = mode; }
      method solver_count (line 153) | inline static int solver_count() { return Get().solver_count_; }
      method set_solver_count (line 154) | inline static void set_solver_count(int val) { Get().solver_count_ =...
      method root_solver (line 155) | inline static bool root_solver() { return Get().root_solver_; }
      method set_root_solver (line 156) | inline static void set_root_solver(bool val) { Get().root_solver_ = ...

FILE: include/caffe/common_layers.hpp
  type caffe (line 16) | namespace caffe {
    class ArgMaxLayer (line 29) | class ArgMaxLayer : public Layer<Dtype> {
      method ArgMaxLayer (line 39) | explicit ArgMaxLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 47) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 48) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Backward_cpu (line 65) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
    class ConcatLayer (line 78) | class ConcatLayer : public Layer<Dtype> {
      method ConcatLayer (line 80) | explicit ConcatLayer(const LayerParameter& param)
      method MinBottomBlobs (line 88) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 89) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class EltwiseLayer (line 153) | class EltwiseLayer : public Layer<Dtype> {
      method EltwiseLayer (line 155) | explicit EltwiseLayer(const LayerParameter& param)
      method MinBottomBlobs (line 163) | virtual inline int MinBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 164) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class EmbedLayer (line 191) | class EmbedLayer : public Layer<Dtype> {
      method EmbedLayer (line 193) | explicit EmbedLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 201) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 202) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class FilterLayer (line 228) | class FilterLayer : public Layer<Dtype> {
      method FilterLayer (line 230) | explicit FilterLayer(const LayerParameter& param)
      method MinBottomBlobs (line 238) | virtual inline int MinBottomBlobs() const { return 2; }
      method MinTopBlobs (line 239) | virtual inline int MinTopBlobs() const { return 1; }
    class FlattenLayer (line 295) | class FlattenLayer : public Layer<Dtype> {
      method FlattenLayer (line 297) | explicit FlattenLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 303) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 304) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class InnerProductLayer (line 338) | class InnerProductLayer : public Layer<Dtype> {
      method InnerProductLayer (line 340) | explicit InnerProductLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 348) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 349) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class MVNLayer (line 374) | class MVNLayer : public Layer<Dtype> {
      method MVNLayer (line 376) | explicit MVNLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 382) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 383) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class ReshapeLayer (line 409) | class ReshapeLayer : public Layer<Dtype> {
      method ReshapeLayer (line 411) | explicit ReshapeLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 419) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 420) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method Forward_cpu (line 423) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 425) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Forward_gpu (line 427) | virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_gpu (line 429) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
    class ReductionLayer (line 448) | class ReductionLayer : public Layer<Dtype> {
      method ReductionLayer (line 450) | explicit ReductionLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 458) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 459) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class SilenceLayer (line 490) | class SilenceLayer : public Layer<Dtype> {
      method SilenceLayer (line 492) | explicit SilenceLayer(const LayerParameter& param)
      method Reshape (line 494) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method MinBottomBlobs (line 498) | virtual inline int MinBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 499) | virtual inline int ExactNumTopBlobs() const { return 0; }
      method Forward_cpu (line 502) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    class SoftmaxLayer (line 520) | class SoftmaxLayer : public Layer<Dtype> {
      method SoftmaxLayer (line 522) | explicit SoftmaxLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 528) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 529) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class CuDNNSoftmaxLayer (line 556) | class CuDNNSoftmaxLayer : public SoftmaxLayer<Dtype> {
      method CuDNNSoftmaxLayer (line 558) | explicit CuDNNSoftmaxLayer(const LayerParameter& param)
    class SplitLayer (line 586) | class SplitLayer : public Layer<Dtype> {
      method SplitLayer (line 588) | explicit SplitLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 594) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 595) | virtual inline int MinTopBlobs() const { return 1; }
    class SliceLayer (line 617) | class SliceLayer : public Layer<Dtype> {
      method SliceLayer (line 619) | explicit SliceLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 627) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 628) | virtual inline int MinTopBlobs() const { return 1; }
    class TileLayer (line 651) | class TileLayer : public Layer<Dtype> {
      method TileLayer (line 653) | explicit TileLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 659) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 660) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: include/caffe/data_layers.hpp
  type caffe (line 21) | namespace caffe {
    class BaseDataLayer (line 29) | class BaseDataLayer : public Layer<Dtype> {
      method ShareInParallel (line 38) | virtual inline bool ShareInParallel() const { return true; }
      method DataLayerSetUp (line 39) | virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method Reshape (line 42) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 45) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 47) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
    class Batch (line 57) | class Batch {
    class BasePrefetchingDataLayer (line 63) | class BasePrefetchingDataLayer :
    class DataLayer (line 93) | class DataLayer : public BasePrefetchingDataLayer<Dtype> {
      method ShareInParallel (line 100) | virtual inline bool ShareInParallel() const { return false; }
      method ExactNumBottomBlobs (line 102) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 103) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 104) | virtual inline int MaxTopBlobs() const { return 2; }
    class DummyDataLayer (line 118) | class DummyDataLayer : public Layer<Dtype> {
      method DummyDataLayer (line 120) | explicit DummyDataLayer(const LayerParameter& param)
      method ShareInParallel (line 125) | virtual inline bool ShareInParallel() const { return true; }
      method Reshape (line 127) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 131) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 132) | virtual inline int MinTopBlobs() const { return 1; }
      method Backward_cpu (line 137) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 139) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
    class HDF5DataLayer (line 152) | class HDF5DataLayer : public Layer<Dtype> {
      method HDF5DataLayer (line 154) | explicit HDF5DataLayer(const LayerParameter& param)
      method ShareInParallel (line 160) | virtual inline bool ShareInParallel() const { return true; }
      method Reshape (line 162) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 166) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method MinTopBlobs (line 167) | virtual inline int MinTopBlobs() const { return 1; }
      method Backward_cpu (line 174) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      method Backward_gpu (line 176) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
    class HDF5OutputLayer (line 195) | class HDF5OutputLayer : public Layer<Dtype> {
      method HDF5OutputLayer (line 197) | explicit HDF5OutputLayer(const LayerParameter& param)
      method ShareInParallel (line 203) | virtual inline bool ShareInParallel() const { return true; }
      method Reshape (line 205) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ExactNumBottomBlobs (line 210) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method ExactNumTopBlobs (line 211) | virtual inline int ExactNumTopBlobs() const { return 0; }
      method file_name (line 213) | inline std::string file_name() const { return file_name_; }
    class ImageDataLayer (line 239) | class ImageDataLayer : public BasePrefetchingDataLayer<Dtype> {
      method ImageDataLayer (line 241) | explicit ImageDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 248) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 249) | virtual inline int ExactNumTopBlobs() const { return 2; }
    class MemoryDataLayer (line 266) | class MemoryDataLayer : public BaseDataLayer<Dtype> {
      method MemoryDataLayer (line 268) | explicit MemoryDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 274) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 275) | virtual inline int ExactNumTopBlobs() const { return 2; }
      method batch_size (line 286) | int batch_size() { return batch_size_; }
      method channels (line 287) | int channels() { return channels_; }
      method height (line 288) | int height() { return height_; }
      method width (line 289) | int width() { return width_; }
    class WindowDataLayer (line 312) | class WindowDataLayer : public BasePrefetchingDataLayer<Dtype> {
      method WindowDataLayer (line 314) | explicit WindowDataLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 321) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 322) | virtual inline int ExactNumTopBlobs() const { return 2; }
      type WindowField (line 330) | enum WindowField { IMAGE_INDEX, LABEL, OVERLAP, X1, Y1, X2, Y2, NUM }

FILE: include/caffe/data_reader.hpp
  type caffe (line 13) | namespace caffe {
    class DataReader (line 23) | class DataReader {
      class QueuePair (line 37) | class QueuePair {
      class Body (line 49) | class Body : public InternalThread {
      method string (line 68) | static inline string source_key(const LayerParameter& param) {

FILE: include/caffe/data_transformer.hpp
  type caffe (line 10) | namespace caffe {
    class DataTransformer (line 17) | class DataTransformer {

FILE: include/caffe/filler.hpp
  type caffe (line 16) | namespace caffe {
    class Filler (line 20) | class Filler {
      method Filler (line 22) | explicit Filler(const FillerParameter& param) : filler_param_(param) {}
    class ConstantFiller (line 32) | class ConstantFiller : public Filler<Dtype> {
      method ConstantFiller (line 34) | explicit ConstantFiller(const FillerParameter& param)
      method Fill (line 36) | virtual void Fill(Blob<Dtype>* blob) {
    class UniformFiller (line 51) | class UniformFiller : public Filler<Dtype> {
      method UniformFiller (line 53) | explicit UniformFiller(const FillerParameter& param)
      method Fill (line 55) | virtual void Fill(Blob<Dtype>* blob) {
    class GaussianFiller (line 66) | class GaussianFiller : public Filler<Dtype> {
      method GaussianFiller (line 68) | explicit GaussianFiller(const FillerParameter& param)
      method Fill (line 70) | virtual void Fill(Blob<Dtype>* blob) {
    class PositiveUnitballFiller (line 102) | class PositiveUnitballFiller : public Filler<Dtype> {
      method PositiveUnitballFiller (line 104) | explicit PositiveUnitballFiller(const FillerParameter& param)
      method Fill (line 106) | virtual void Fill(Blob<Dtype>* blob) {
    class XavierFiller (line 145) | class XavierFiller : public Filler<Dtype> {
      method XavierFiller (line 147) | explicit XavierFiller(const FillerParameter& param)
      method Fill (line 149) | virtual void Fill(Blob<Dtype>* blob) {
    class MSRAFiller (line 187) | class MSRAFiller : public Filler<Dtype> {
      method MSRAFiller (line 189) | explicit MSRAFiller(const FillerParameter& param)
      method Fill (line 191) | virtual void Fill(Blob<Dtype>* blob) {
    class BilinearFiller (line 245) | class BilinearFiller : public Filler<Dtype> {
      method BilinearFiller (line 247) | explicit BilinearFiller(const FillerParameter& param)
      method Fill (line 249) | virtual void Fill(Blob<Dtype>* blob) {

FILE: include/caffe/internal_thread.hpp
  type boost (line 10) | namespace boost { class thread; }
    class thread (line 10) | class thread
  type caffe (line 12) | namespace caffe {
    class InternalThread (line 19) | class InternalThread {
      method InternalThread (line 21) | InternalThread() : thread_() {}
      method InternalThreadEntry (line 39) | virtual void InternalThreadEntry() {}

FILE: include/caffe/layer.hpp
  type boost (line 18) | namespace boost { class mutex; }
    class mutex (line 18) | class mutex
  type caffe (line 20) | namespace caffe {
    class Layer (line 33) | class Layer {
      method Layer (line 40) | explicit Layer(const LayerParameter& param)
      method SetUp (line 67) | void SetUp(const vector<Blob<Dtype>*>& bottom,
      method LayerSetUp (line 92) | virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method ShareInParallel (line 101) | virtual inline bool ShareInParallel() const { return false; }
      method IsShared (line 107) | inline bool IsShared() const { return is_shared_; }
      method SetShared (line 113) | inline void SetShared(bool is_shared) {
      method LayerParameter (line 189) | const LayerParameter& layer_param() const { return layer_param_; }
      method Dtype (line 199) | inline Dtype loss(const int top_index) const {
      method set_loss (line 206) | inline void set_loss(const int top_index, const Dtype value) {
      method ExactNumBottomBlobs (line 225) | virtual inline int ExactNumBottomBlobs() const { return -1; }
      method MinBottomBlobs (line 233) | virtual inline int MinBottomBlobs() const { return -1; }
      method MaxBottomBlobs (line 241) | virtual inline int MaxBottomBlobs() const { return -1; }
      method ExactNumTopBlobs (line 249) | virtual inline int ExactNumTopBlobs() const { return -1; }
      method MinTopBlobs (line 257) | virtual inline int MinTopBlobs() const { return -1; }
      method MaxTopBlobs (line 265) | virtual inline int MaxTopBlobs() const { return -1; }
      method EqualNumBottomTopBlobs (line 273) | virtual inline bool EqualNumBottomTopBlobs() const { return false; }
      method AutoTopBlobs (line 283) | virtual inline bool AutoTopBlobs() const { return false; }
      method AllowForceBackward (line 293) | virtual inline bool AllowForceBackward(const int bottom_index) const {
      method param_propagate_down (line 304) | inline bool param_propagate_down(const int param_id) {
      method set_param_propagate_down (line 312) | inline void set_param_propagate_down(const int param_id, const bool ...
      method Forward_gpu (line 341) | virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_gpu (line 359) | virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      method CheckBlobCounts (line 371) | virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,
      method SetLossWeights (line 414) | inline void SetLossWeights(const vector<Blob<Dtype>*>& top) {
    function Dtype (line 451) | inline Dtype Layer<Dtype>::Forward(const vector<Blob<Dtype>*>& bottom,

FILE: include/caffe/layer_factory.hpp
  type caffe (line 49) | namespace caffe {
    class Layer (line 52) | class Layer
    class LayerRegistry (line 55) | class LayerRegistry {
      method CreatorRegistry (line 60) | static CreatorRegistry& Registry() {
      method AddCreator (line 66) | static void AddCreator(const string& type, Creator creator) {
      method CreateLayer (line 74) | static shared_ptr<Layer<Dtype> > CreateLayer(const LayerParameter& p...
      method LayerTypeList (line 85) | static vector<string> LayerTypeList() {
      method LayerRegistry (line 98) | LayerRegistry() {}
      method string (line 100) | static string LayerTypeListString() {
    class LayerRegisterer (line 116) | class LayerRegisterer {
      method LayerRegisterer (line 118) | LayerRegisterer(const string& type,

FILE: include/caffe/layers/data_heatmap.hpp
  type caffe (line 17) | namespace caffe
    class DataHeatmapLayer (line 22) | class DataHeatmapLayer: public BasePrefetchingDataLayer<Dtype>
      method DataHeatmapLayer (line 27) | explicit DataHeatmapLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 35) | virtual inline int ExactNumBottomBlobs() const { return 0; }
      method ExactNumTopBlobs (line 36) | virtual inline int ExactNumTopBlobs() const { return 2; }

FILE: include/caffe/layers/euclidean_loss_heatmap_layer.hpp
  type caffe (line 15) | namespace caffe
    class EuclideanLossHeatmapLayer (line 20) | class EuclideanLossHeatmapLayer : public LossLayer<Dtype> {
      method EuclideanLossHeatmapLayer (line 22) | explicit EuclideanLossHeatmapLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 27) | virtual inline int ExactNumBottomBlobs() const { return 3; }
      method AllowForceBackward (line 39) | virtual inline bool AllowForceBackward(const int bottom_index) const {

FILE: include/caffe/loss_layers.hpp
  type caffe (line 14) | namespace caffe {
    class AccuracyLayer (line 23) | class AccuracyLayer : public Layer<Dtype> {
      method AccuracyLayer (line 33) | explicit AccuracyLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 41) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method MinTopBlobs (line 45) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlos (line 46) | virtual inline int MaxTopBlos() const { return 2; }
      method Backward_cpu (line 78) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
    class LossLayer (line 106) | class LossLayer : public Layer<Dtype> {
      method LossLayer (line 108) | explicit LossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 115) | virtual inline int ExactNumBottomBlobs() const { return 2; }
      method AutoTopBlobs (line 123) | virtual inline bool AutoTopBlobs() const { return true; }
      method ExactNumTopBlobs (line 124) | virtual inline int ExactNumTopBlobs() const { return 1; }
      method AllowForceBackward (line 129) | virtual inline bool AllowForceBackward(const int bottom_index) const {
    class ContrastiveLossLayer (line 159) | class ContrastiveLossLayer : public LossLayer<Dtype> {
      method ContrastiveLossLayer (line 161) | explicit ContrastiveLossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 166) | virtual inline int ExactNumBottomBlobs() const { return 3; }
      method AllowForceBackward (line 172) | virtual inline bool AllowForceBackward(const int bottom_index) const {
    class EuclideanLossLayer (line 246) | class EuclideanLossLayer : public LossLayer<Dtype> {
      method EuclideanLossLayer (line 248) | explicit EuclideanLossLayer(const LayerParameter& param)
      method AllowForceBackward (line 258) | virtual inline bool AllowForceBackward(const int bottom_index) const {
    class HingeLossLayer (line 354) | class HingeLossLayer : public LossLayer<Dtype> {
      method HingeLossLayer (line 356) | explicit HingeLossLayer(const LayerParameter& param)
    class InfogainLossLayer (line 430) | class InfogainLossLayer : public LossLayer<Dtype> {
      method InfogainLossLayer (line 432) | explicit InfogainLossLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 442) | virtual inline int ExactNumBottomBlobs() const { return -1; }
      method MinBottomBlobs (line 443) | virtual inline int MinBottomBlobs() const { return 2; }
      method MaxBottomBlobs (line 444) | virtual inline int MaxBottomBlobs() const { return 3; }
    class MultinomialLogisticLossLayer (line 521) | class MultinomialLogisticLossLayer : public LossLayer<Dtype> {
      method MultinomialLogisticLossLayer (line 523) | explicit MultinomialLogisticLossLayer(const LayerParameter& param)
    class SigmoidCrossEntropyLossLayer (line 597) | class SigmoidCrossEntropyLossLayer : public LossLayer<Dtype> {
      method SigmoidCrossEntropyLossLayer (line 599) | explicit SigmoidCrossEntropyLossLayer(const LayerParameter& param)
    class SoftmaxLayer (line 661) | class SoftmaxLayer
    class SoftmaxWithLossLayer (line 692) | class SoftmaxWithLossLayer : public LossLayer<Dtype> {
      method SoftmaxWithLossLayer (line 702) | explicit SoftmaxWithLossLayer(const LayerParameter& param)
      method ExactNumTopBlobs (line 710) | virtual inline int ExactNumTopBlobs() const { return -1; }
      method MinTopBlobs (line 711) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 712) | virtual inline int MaxTopBlobs() const { return 2; }

FILE: include/caffe/net.hpp
  type caffe (line 15) | namespace caffe {
    class Net (line 24) | class Net {
      method Dtype (line 85) | Dtype ForwardBackward(const vector<Blob<Dtype>* > & bottom) {
      method string (line 123) | inline const string& name() const { return name_; }
      method Phase (line 137) | inline Phase phase() const { return phase_; }
      method num_inputs (line 183) | inline int num_inputs() const { return net_input_blobs_.size(); }
      method num_outputs (line 184) | inline int num_outputs() const { return net_output_blobs_.size(); }
      method set_debug_info (line 202) | void set_debug_info(const bool value) { debug_info_ = value; }

FILE: include/caffe/neuron_layers.hpp
  type caffe (line 16) | namespace caffe {
    class NeuronLayer (line 25) | class NeuronLayer : public Layer<Dtype> {
      method NeuronLayer (line 27) | explicit NeuronLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 32) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 33) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class AbsValLayer (line 47) | class AbsValLayer : public NeuronLayer<Dtype> {
      method AbsValLayer (line 49) | explicit AbsValLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 55) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 56) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class BNLLLayer (line 106) | class BNLLLayer : public NeuronLayer<Dtype> {
      method BNLLLayer (line 108) | explicit BNLLLayer(const LayerParameter& param)
    class DropoutLayer (line 154) | class DropoutLayer : public NeuronLayer<Dtype> {
      method DropoutLayer (line 162) | explicit DropoutLayer(const LayerParameter& param)
    class ExpLayer (line 212) | class ExpLayer : public NeuronLayer<Dtype> {
      method ExpLayer (line 222) | explicit ExpLayer(const LayerParameter& param)
    class LogLayer (line 276) | class LogLayer : public NeuronLayer<Dtype> {
      method LogLayer (line 286) | explicit LogLayer(const LayerParameter& param)
    class PowerLayer (line 342) | class PowerLayer : public NeuronLayer<Dtype> {
      method PowerLayer (line 351) | explicit PowerLayer(const LayerParameter& param)
    class ReLULayer (line 414) | class ReLULayer : public NeuronLayer<Dtype> {
      method ReLULayer (line 422) | explicit ReLULayer(const LayerParameter& param)
    class CuDNNReLULayer (line 483) | class CuDNNReLULayer : public ReLULayer<Dtype> {
      method CuDNNReLULayer (line 485) | explicit CuDNNReLULayer(const LayerParameter& param)
    class SigmoidLayer (line 515) | class SigmoidLayer : public NeuronLayer<Dtype> {
      method SigmoidLayer (line 517) | explicit SigmoidLayer(const LayerParameter& param)
    class CuDNNSigmoidLayer (line 566) | class CuDNNSigmoidLayer : public SigmoidLayer<Dtype> {
      method CuDNNSigmoidLayer (line 568) | explicit CuDNNSigmoidLayer(const LayerParameter& param)
    class TanHLayer (line 598) | class TanHLayer : public NeuronLayer<Dtype> {
      method TanHLayer (line 600) | explicit TanHLayer(const LayerParameter& param)
    class CuDNNTanHLayer (line 651) | class CuDNNTanHLayer : public TanHLayer<Dtype> {
      method CuDNNTanHLayer (line 653) | explicit CuDNNTanHLayer(const LayerParameter& param)
    class ThresholdLayer (line 679) | class ThresholdLayer : public NeuronLayer<Dtype> {
      method ThresholdLayer (line 687) | explicit ThresholdLayer(const LayerParameter& param)
      method Backward_cpu (line 714) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
    class PReLULayer (line 731) | class PReLULayer : public NeuronLayer<Dtype> {
      method PReLULayer (line 741) | explicit PReLULayer(const LayerParameter& param)

FILE: include/caffe/parallel.hpp
  type caffe (line 17) | namespace caffe {
    class Params (line 23) | class Params {
      method size (line 29) | inline size_t size() const {
      method Dtype (line 32) | inline Dtype* data() const {
      method Dtype (line 35) | inline Dtype* diff() const {
    class GPUParams (line 49) | class GPUParams : public Params<Dtype> {
    class DevicePair (line 62) | class DevicePair {
      method DevicePair (line 64) | DevicePair(int parent, int device)
      method parent (line 68) | inline int parent() {
      method device (line 71) | inline int device() {
    class P2PSync (line 85) | class P2PSync : public GPUParams<Dtype>, public Solver<Dtype>::Callback,

FILE: include/caffe/python_layer.hpp
  type caffe (line 11) | namespace caffe {
    class PythonLayer (line 14) | class PythonLayer : public Layer<Dtype> {
      method PythonLayer (line 16) | PythonLayer(PyObject* self, const LayerParameter& param)
      method LayerSetUp (line 19) | virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      method Reshape (line 25) | virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      method ShareInParallel (line 30) | virtual inline bool ShareInParallel() const {
      method Forward_cpu (line 37) | virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      method Backward_cpu (line 41) | virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,

FILE: include/caffe/solver.hpp
  type caffe (line 9) | namespace caffe {
    type SolverAction (line 19) | namespace SolverAction {
      type Enum (line 20) | enum Enum {
    class Solver (line 40) | class Solver {
      method Solve (line 57) | inline void Solve(const string resume_file) { Solve(resume_file.c_st...
      method SolverParameter (line 64) | inline const SolverParameter& param() const { return param_; }
      method net (line 65) | inline shared_ptr<Net<Dtype> > net() { return net_; }
      method iter (line 69) | int iter() { return iter_; }
      class Callback (line 72) | class Callback {
      method add_callback (line 81) | void add_callback(Callback* value) {
    class WorkerSolver (line 130) | class WorkerSolver : public Solver<Dtype> {
      method WorkerSolver (line 132) | explicit WorkerSolver(const SolverParameter& param,
      method ApplyUpdate (line 137) | void ApplyUpdate() {}
      method SnapshotSolverState (line 138) | void SnapshotSolverState(const string& model_filename) {
      method RestoreSolverStateFromBinaryProto (line 141) | void RestoreSolverStateFromBinaryProto(const string& state_file) {
      method RestoreSolverStateFromHDF5 (line 144) | void RestoreSolverStateFromHDF5(const string& state_file) {
    class SGDSolver (line 154) | class SGDSolver : public Solver<Dtype> {
      method SGDSolver (line 156) | explicit SGDSolver(const SolverParameter& param)
      method SGDSolver (line 158) | explicit SGDSolver(const string& param_file)
    class NesterovSolver (line 186) | class NesterovSolver : public SGDSolver<Dtype> {
      method NesterovSolver (line 188) | explicit NesterovSolver(const SolverParameter& param)
      method NesterovSolver (line 190) | explicit NesterovSolver(const string& param_file)
    class AdaGradSolver (line 200) | class AdaGradSolver : public SGDSolver<Dtype> {
      method AdaGradSolver (line 202) | explicit AdaGradSolver(const SolverParameter& param)
      method AdaGradSolver (line 204) | explicit AdaGradSolver(const string& param_file)
      method constructor_sanity_check (line 209) | void constructor_sanity_check() {
    class RMSPropSolver (line 219) | class RMSPropSolver : public SGDSolver<Dtype> {
      method RMSPropSolver (line 221) | explicit RMSPropSolver(const SolverParameter& param)
      method RMSPropSolver (line 223) | explicit RMSPropSolver(const string& param_file)
      method constructor_sanity_check (line 228) | void constructor_sanity_check() {
    class AdaDeltaSolver (line 241) | class AdaDeltaSolver : public SGDSolver<Dtype> {
      method AdaDeltaSolver (line 243) | explicit AdaDeltaSolver(const SolverParameter& param)
      method AdaDeltaSolver (line 245) | explicit AdaDeltaSolver(const string& param_file)
    class AdamSolver (line 264) | class AdamSolver : public SGDSolver<Dtype> {
      method AdamSolver (line 266) | explicit AdamSolver(const SolverParameter& param)
      method AdamSolver (line 268) | explicit AdamSolver(const string& param_file)

FILE: include/caffe/syncedmem.hpp
  type caffe (line 9) | namespace caffe {
    function CaffeMallocHost (line 16) | inline void CaffeMallocHost(void** ptr, size_t size) {
    function CaffeFreeHost (line 27) | inline void CaffeFreeHost(void* ptr) {
    class SyncedMemory (line 44) | class SyncedMemory {
      method SyncedMemory (line 46) | SyncedMemory()
      method SyncedMemory (line 49) | explicit SyncedMemory(size_t size)
      type SyncedHead (line 59) | enum SyncedHead { UNINITIALIZED, HEAD_AT_CPU, HEAD_AT_GPU, SYNCED }
      method SyncedHead (line 60) | SyncedHead head() { return head_; }
      method size (line 61) | size_t size() { return size_; }

FILE: include/caffe/test/test_caffe_main.hpp
  type caffe (line 28) | namespace caffe {
    class MultiDeviceTest (line 31) | class MultiDeviceTest : public ::testing::Test {
      method MultiDeviceTest (line 35) | MultiDeviceTest() {
    type CPUDevice (line 44) | struct CPUDevice {
    class CPUDeviceTest (line 50) | class CPUDeviceTest : public MultiDeviceTest<CPUDevice<Dtype> > {
    type GPUDevice (line 61) | struct GPUDevice {
    class GPUDeviceTest (line 67) | class GPUDeviceTest : public MultiDeviceTest<GPUDevice<Dtype> > {

FILE: include/caffe/test/test_gradient_check_util.hpp
  type caffe (line 14) | namespace caffe {
    class GradientChecker (line 19) | class GradientChecker {
      method GradientChecker (line 24) | GradientChecker(const Dtype stepsize, const Dtype threshold,
      method CheckGradient (line 33) | void CheckGradient(Layer<Dtype>* layer, const vector<Blob<Dtype>*>& ...
    function Dtype (line 232) | Dtype GradientChecker<Dtype>::GetObjAndGradient(const Layer<Dtype>& la...

FILE: include/caffe/util/benchmark.hpp
  type caffe (line 8) | namespace caffe {
    class Timer (line 10) | class Timer {
      method initted (line 20) | inline bool initted() { return initted_; }
      method running (line 21) | inline bool running() { return running_; }
      method has_run_at_least_once (line 22) | inline bool has_run_at_least_once() { return has_run_at_least_once_; }
    class CPUTimer (line 40) | class CPUTimer : public Timer {

FILE: include/caffe/util/blocking_queue.hpp
  type caffe (line 9) | namespace caffe {
    class BlockingQueue (line 12) | class BlockingQueue {
      class sync (line 37) | class sync

FILE: include/caffe/util/cudnn.hpp
  type caffe (line 45) | namespace caffe {
    type cudnn (line 47) | namespace cudnn {
      class dataType (line 49) | class dataType
      class dataType<float> (line 50) | class dataType<float>  {
      class dataType<double> (line 56) | class dataType<double> {
      function createTensor4dDesc (line 64) | inline void createTensor4dDesc(cudnnTensorDescriptor_t* desc) {
      function setTensor4dDesc (line 69) | inline void setTensor4dDesc(cudnnTensorDescriptor_t* desc,
      function setTensor4dDesc (line 77) | inline void setTensor4dDesc(cudnnTensorDescriptor_t* desc,
      function createFilterDesc (line 88) | inline void createFilterDesc(cudnnFilterDescriptor_t* desc,
      function createConvolutionDesc (line 96) | inline void createConvolutionDesc(cudnnConvolutionDescriptor_t* conv) {
      function setConvolutionDesc (line 101) | inline void setConvolutionDesc(cudnnConvolutionDescriptor_t* conv,
      function createPoolingDesc (line 109) | inline void createPoolingDesc(cudnnPoolingDescriptor_t* pool_desc,

FILE: include/caffe/util/db.hpp
  type caffe (line 9) | namespace caffe { namespace db {
    type db (line 9) | namespace db {
      type Mode (line 11) | enum Mode { READ, WRITE, NEW }
      class Cursor (line 13) | class Cursor {
        method Cursor (line 15) | Cursor() { }
      class Transaction (line 26) | class Transaction {
        method Transaction (line 28) | Transaction() { }
      class DB (line 36) | class DB {
        method DB (line 38) | DB() { }

FILE: include/caffe/util/db_leveldb.hpp
  type caffe (line 11) | namespace caffe { namespace db {
    type db (line 11) | namespace db {
      class LevelDBCursor (line 13) | class LevelDBCursor : public Cursor {
        method LevelDBCursor (line 15) | explicit LevelDBCursor(leveldb::Iterator* iter)
        method SeekToFirst (line 18) | virtual void SeekToFirst() { iter_->SeekToFirst(); }
        method Next (line 19) | virtual void Next() { iter_->Next(); }
        method string (line 20) | virtual string key() { return iter_->key().ToString(); }
        method string (line 21) | virtual string value() { return iter_->value().ToString(); }
        method valid (line 22) | virtual bool valid() { return iter_->Valid(); }
      class LevelDBTransaction (line 28) | class LevelDBTransaction : public Transaction {
        method LevelDBTransaction (line 30) | explicit LevelDBTransaction(leveldb::DB* db) : db_(db) { CHECK_NOT...
        method Put (line 31) | virtual void Put(const string& key, const string& value) {
        method Commit (line 34) | virtual void Commit() {
      class LevelDB (line 47) | class LevelDB : public DB {
        method LevelDB (line 49) | LevelDB() : db_(NULL) { }
        method Close (line 52) | virtual void Close() {
        method LevelDBCursor (line 58) | virtual LevelDBCursor* NewCursor() {
        method LevelDBTransaction (line 61) | virtual LevelDBTransaction* NewTransaction() {

FILE: include/caffe/util/db_lmdb.hpp
  type caffe (line 10) | namespace caffe { namespace db {
    type db (line 10) | namespace db {
      function MDB_CHECK (line 12) | inline void MDB_CHECK(int mdb_status) {
      class LMDBCursor (line 16) | class LMDBCursor : public Cursor {
        method LMDBCursor (line 18) | explicit LMDBCursor(MDB_txn* mdb_txn, MDB_cursor* mdb_cursor)
        method SeekToFirst (line 26) | virtual void SeekToFirst() { Seek(MDB_FIRST); }
        method Next (line 27) | virtual void Next() { Seek(MDB_NEXT); }
        method string (line 28) | virtual string key() {
        method string (line 31) | virtual string value() {
        method valid (line 35) | virtual bool valid() { return valid_; }
        method Seek (line 38) | void Seek(MDB_cursor_op op) {
      class LMDBTransaction (line 54) | class LMDBTransaction : public Transaction {
        method LMDBTransaction (line 56) | explicit LMDBTransaction(MDB_dbi* mdb_dbi, MDB_txn* mdb_txn)
        method Commit (line 59) | virtual void Commit() { MDB_CHECK(mdb_txn_commit(mdb_txn_)); }
      class LMDB (line 68) | class LMDB : public DB {
        method LMDB (line 70) | LMDB() : mdb_env_(NULL) { }
        method Close (line 73) | virtual void Close() {

FILE: include/caffe/util/device_alternate.hpp
  type caffe (line 78) | namespace caffe {
    function CAFFE_GET_BLOCKS (line 94) | inline int CAFFE_GET_BLOCKS(const int N) {

FILE: include/caffe/util/hdf5.hpp
  type caffe (line 11) | namespace caffe {

FILE: include/caffe/util/im2col.hpp
  type caffe (line 4) | namespace caffe {

FILE: include/caffe/util/insert_splits.hpp
  type caffe (line 8) | namespace caffe {

FILE: include/caffe/util/io.hpp
  type caffe (line 13) | namespace caffe {
    function MakeTempFilename (line 17) | inline void MakeTempFilename(string* temp_filename) {
    function MakeTempDir (line 30) | inline void MakeTempDir(string* temp_dirname) {
    function ReadProtoFromTextFile (line 45) | inline bool ReadProtoFromTextFile(const string& filename, Message* pro...
    function ReadProtoFromTextFileOrDie (line 49) | inline void ReadProtoFromTextFileOrDie(const char* filename, Message* ...
    function ReadProtoFromTextFileOrDie (line 53) | inline void ReadProtoFromTextFileOrDie(const string& filename, Message...
    function WriteProtoToTextFile (line 58) | inline void WriteProtoToTextFile(const Message& proto, const string& f...
    function ReadProtoFromBinaryFile (line 64) | inline bool ReadProtoFromBinaryFile(const string& filename, Message* p...
    function ReadProtoFromBinaryFileOrDie (line 68) | inline void ReadProtoFromBinaryFileOrDie(const char* filename, Message...
    function ReadProtoFromBinaryFileOrDie (line 72) | inline void ReadProtoFromBinaryFileOrDie(const string& filename,
    function WriteProtoToBinaryFile (line 79) | inline void WriteProtoToBinaryFile(
    function ReadFileToDatum (line 86) | inline bool ReadFileToDatum(const string& filename, Datum* datum) {
    function ReadImageToDatum (line 94) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 100) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 105) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 110) | inline bool ReadImageToDatum(const string& filename, const int label,
    function ReadImageToDatum (line 115) | inline bool ReadImageToDatum(const string& filename, const int label,

FILE: include/caffe/util/math_functions.hpp
  type caffe (line 13) | namespace caffe {
    function caffe_memset (line 42) | inline void caffe_memset(const size_t N, const int alpha, void* X) {
    function caffe_sign (line 114) | inline int8_t caffe_sign(Dtype val) {
    function caffe_gpu_memset (line 177) | inline void caffe_gpu_memset(const size_t N, const int alpha, void* X) {

FILE: include/caffe/util/mkl_alternate.hpp
  function cblas_saxpby (line 83) | inline void cblas_saxpby(const int N, const float alpha, const float* X,
  function cblas_daxpby (line 89) | inline void cblas_daxpby(const int N, const double alpha, const double* X,

FILE: include/caffe/util/rng.hpp
  type caffe (line 12) | namespace caffe {
    function rng_t (line 16) | inline rng_t* caffe_rng() {
    function shuffle (line 22) | inline void shuffle(RandomAccessIterator begin, RandomAccessIterator end,
    function shuffle (line 38) | inline void shuffle(RandomAccessIterator begin, RandomAccessIterator e...

FILE: include/caffe/util/signal_handler.h
  function namespace (line 7) | namespace caffe {

FILE: include/caffe/util/upgrade_proto.hpp
  type caffe (line 8) | namespace caffe {

FILE: include/caffe/vision_layers.hpp
  type caffe (line 17) | namespace caffe {
    class BaseConvolutionLayer (line 24) | class BaseConvolutionLayer : public Layer<Dtype> {
      method BaseConvolutionLayer (line 26) | explicit BaseConvolutionLayer(const LayerParameter& param)
      method MinBottomBlobs (line 33) | virtual inline int MinBottomBlobs() const { return 1; }
      method MinTopBlobs (line 34) | virtual inline int MinTopBlobs() const { return 1; }
      method EqualNumBottomTopBlobs (line 35) | virtual inline bool EqualNumBottomTopBlobs() const { return true; }
      method conv_im2col_cpu (line 81) | inline void conv_im2col_cpu(const Dtype* data, Dtype* col_buff) {
      method conv_col2im_cpu (line 85) | inline void conv_col2im_cpu(const Dtype* col_buff, Dtype* data) {
      method conv_im2col_gpu (line 90) | inline void conv_im2col_gpu(const Dtype* data, Dtype* col_buff) {
      method conv_col2im_gpu (line 94) | inline void conv_col2im_gpu(const Dtype* col_buff, Dtype* data) {
    class ConvolutionLayer (line 131) | class ConvolutionLayer : public BaseConvolutionLayer<Dtype> {
      method ConvolutionLayer (line 161) | explicit ConvolutionLayer(const LayerParameter& param)
      method reverse_dimensions (line 175) | virtual inline bool reverse_dimensions() { return false; }
    class DeconvolutionLayer (line 194) | class DeconvolutionLayer : public BaseConvolutionLayer<Dtype> {
      method DeconvolutionLayer (line 196) | explicit DeconvolutionLayer(const LayerParameter& param)
      method reverse_dimensions (line 210) | virtual inline bool reverse_dimensions() { return true; }
    class CuDNNConvolutionLayer (line 230) | class CuDNNConvolutionLayer : public ConvolutionLayer<Dtype> {
      method CuDNNConvolutionLayer (line 232) | explicit CuDNNConvolutionLayer(const LayerParameter& param)
    class Im2colLayer (line 267) | class Im2colLayer : public Layer<Dtype> {
      method Im2colLayer (line 269) | explicit Im2colLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 277) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 278) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class PoolingLayer (line 298) | class PoolingLayer
      method PoolingLayer (line 385) | explicit PoolingLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 393) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 394) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 397) | virtual inline int MaxTopBlobs() const {
    class SplitLayer (line 299) | class SplitLayer
    class LRNLayer (line 307) | class LRNLayer : public Layer<Dtype> {
      method LRNLayer (line 309) | explicit LRNLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 317) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 318) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class PoolingLayer (line 383) | class PoolingLayer : public Layer<Dtype> {
      method PoolingLayer (line 385) | explicit PoolingLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 393) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method MinTopBlobs (line 394) | virtual inline int MinTopBlobs() const { return 1; }
      method MaxTopBlobs (line 397) | virtual inline int MaxTopBlobs() const {
    class CuDNNPoolingLayer (line 429) | class CuDNNPoolingLayer : public PoolingLayer<Dtype> {
      method CuDNNPoolingLayer (line 431) | explicit CuDNNPoolingLayer(const LayerParameter& param)
      method MinTopBlobs (line 439) | virtual inline int MinTopBlobs() const { return -1; }
      method ExactNumTopBlobs (line 440) | virtual inline int ExactNumTopBlobs() const { return 1; }
    class SPPLayer (line 463) | class SPPLayer : public Layer<Dtype> {
      method SPPLayer (line 465) | explicit SPPLayer(const LayerParameter& param)
      method ExactNumBottomBlobs (line 473) | virtual inline int ExactNumBottomBlobs() const { return 1; }
      method ExactNumTopBlobs (line 474) | virtual inline int ExactNumTopBlobs() const { return 1; }

FILE: matlab/+caffe/private/caffe_.cpp
  function mxCHECK (line 25) | inline void mxCHECK(bool expr, const char* msg) {
  function mxERROR (line 30) | inline void mxERROR(const char* msg) { mexErrMsgTxt(msg); }
  function mxCHECK_FILE_EXIST (line 33) | void mxCHECK_FILE_EXIST(const char* file) {
  type WhichMemory (line 54) | enum WhichMemory { DATA, DIFF }
  function mx_mat_to_blob (line 57) | static void mx_mat_to_blob(const mxArray* mx_mat, Blob<float>* blob,
  function mxArray (line 79) | static mxArray* blob_to_mx_mat(const Blob<float>* blob,
  function mxArray (line 110) | static mxArray* int_vec_to_mx_vec(const vector<int>& int_vec) {
  function mxArray (line 120) | static mxArray* str_vec_to_mx_strcell(const vector<std::string>& str_vec) {
  function T (line 136) | static T* handle_to_ptr(const mxArray* mx_handle) {
  function mxArray (line 148) | static mxArray* create_handle_vec(int ptr_num) {
  function setup_handle (line 156) | static void setup_handle(const T* ptr, int index, mxArray* mx_handle_vec) {
  function mxArray (line 166) | static mxArray* ptr_to_handle(const T* ptr) {
  function mxArray (line 174) | static mxArray* ptr_vec_to_handle_vec(const vector<shared_ptr<T> >& ptr_...
  function get_solver (line 186) | static void get_solver(MEX_ARGS) {
  function solver_get_attr (line 198) | static void solver_get_attr(MEX_ARGS) {
  function solver_get_iter (line 214) | static void solver_get_iter(MEX_ARGS) {
  function solver_restore (line 222) | static void solver_restore(MEX_ARGS) {
  function solver_solve (line 233) | static void solver_solve(MEX_ARGS) {
  function solver_step (line 241) | static void solver_step(MEX_ARGS) {
  function get_net (line 250) | static void get_net(MEX_ARGS) {
  function net_get_attr (line 272) | static void net_get_attr(MEX_ARGS) {
  function net_forward (line 297) | static void net_forward(MEX_ARGS) {
  function net_backward (line 305) | static void net_backward(MEX_ARGS) {
  function net_copy_from (line 313) | static void net_copy_from(MEX_ARGS) {
  function net_reshape (line 324) | static void net_reshape(MEX_ARGS) {
  function net_save (line 332) | static void net_save(MEX_ARGS) {
  function layer_get_attr (line 344) | static void layer_get_attr(MEX_ARGS) {
  function layer_get_type (line 358) | static void layer_get_type(MEX_ARGS) {
  function blob_get_shape (line 366) | static void blob_get_shape(MEX_ARGS) {
  function blob_reshape (line 381) | static void blob_reshape(MEX_ARGS) {
  function blob_get_data (line 397) | static void blob_get_data(MEX_ARGS) {
  function blob_set_data (line 405) | static void blob_set_data(MEX_ARGS) {
  function blob_get_diff (line 413) | static void blob_get_diff(MEX_ARGS) {
  function blob_set_diff (line 421) | static void blob_set_diff(MEX_ARGS) {
  function set_mode_cpu (line 429) | static void set_mode_cpu(MEX_ARGS) {
  function set_mode_gpu (line 435) | static void set_mode_gpu(MEX_ARGS) {
  function set_device (line 441) | static void set_device(MEX_ARGS) {
  function get_init_key (line 449) | static void get_init_key(MEX_ARGS) {
  function reset (line 455) | static void reset(MEX_ARGS) {
  function read_mean (line 467) | static void read_mean(MEX_ARGS) {
  type handler_registry (line 484) | struct handler_registry {
  function mexFunction (line 526) | void mexFunction(MEX_ARGS) {

FILE: python/caffe/_caffe.cpp
  type caffe (line 29) | namespace caffe {
    function set_mode_cpu (line 36) | void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); }
    function set_mode_gpu (line 37) | void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); }
    function CheckFile (line 43) | static void CheckFile(const string& filename) {
    function CheckContiguousArray (line 52) | void CheckContiguousArray(PyArrayObject* arr, string name,
    function Net_Init (line 75) | shared_ptr<Net<Dtype> > Net_Init(
    function Net_Init_Load (line 85) | shared_ptr<Net<Dtype> > Net_Init_Load(
    function Net_Save (line 96) | void Net_Save(const Net<Dtype>& net, string filename) {
    function Net_SetInputArrays (line 102) | void Net_SetInputArrays(Net<Dtype>* net, bp::object data_obj,
    type NdarrayConverterGenerator (line 140) | struct NdarrayConverterGenerator {
      type apply (line 141) | struct apply
    type NdarrayConverterGenerator::apply<Dtype*> (line 145) | struct NdarrayConverterGenerator::apply<Dtype*> {
      type type (line 146) | struct type {
        method PyObject (line 147) | PyObject* operator() (Dtype* data) const {
        method PyTypeObject (line 151) | const PyTypeObject* get_pytype() {
    type NdarrayCallPolicies (line 157) | struct NdarrayCallPolicies : public bp::default_call_policies {
      method PyObject (line 159) | PyObject* postcall(PyObject* pyargs, PyObject* result) {
    function Blob_Reshape (line 179) | bp::object Blob_Reshape(bp::tuple args, bp::dict kwargs) {
    function BlobVec_add_blob (line 193) | bp::object BlobVec_add_blob(bp::tuple args, bp::dict kwargs) {
    function BOOST_PYTHON_MODULE (line 210) | BOOST_PYTHON_MODULE(_caffe) {

FILE: python/caffe/classifier.py
  class Classifier (line 11) | class Classifier(caffe.Net):
    method __init__ (line 23) | def __init__(self, model_file, pretrained_file, image_dims=None,
    method predict (line 47) | def predict(self, inputs, oversample=True):

FILE: python/caffe/detector.py
  class Detector (line 22) | class Detector(caffe.Net):
    method __init__ (line 35) | def __init__(self, model_file, pretrained_file, mean=None,
    method detect_windows (line 56) | def detect_windows(self, images_windows):
    method detect_selective_search (line 101) | def detect_selective_search(self, image_fnames):
    method crop (line 125) | def crop(self, im, window):
    method configure_crop (line 181) | def configure_crop(self, context_pad):

FILE: python/caffe/draw.py
  function get_pooling_types_dict (line 27) | def get_pooling_types_dict():
  function get_edge_label (line 37) | def get_edge_label(layer):
  function get_layer_label (line 53) | def get_layer_label(layer, rankdir):
  function choose_color_by_layertype (line 108) | def choose_color_by_layertype(layertype):
  function get_pydot_graph (line 121) | def get_pydot_graph(caffe_net, rankdir, label_edges=True):
  function draw_net (line 180) | def draw_net(caffe_net, rankdir, ext='png'):
  function draw_net_to_file (line 198) | def draw_net_to_file(caffe_net, filename, rankdir='LR'):

FILE: python/caffe/io.py
  function blobproto_to_array (line 18) | def blobproto_to_array(blob, return_diff=False):
  function array_to_blobproto (line 31) | def array_to_blobproto(arr, diff=None):
  function arraylist_to_blobprotovecor_str (line 46) | def arraylist_to_blobprotovecor_str(arraylist):
  function blobprotovector_str_to_arraylist (line 55) | def blobprotovector_str_to_arraylist(str):
  function array_to_datum (line 63) | def array_to_datum(arr, label=0):
  function datum_to_array (line 80) | def datum_to_array(datum):
  class Transformer (line 94) | class Transformer:
    method __init__ (line 105) | def __init__(self, inputs):
    method __check_input (line 113) | def __check_input(self, in_):
    method preprocess (line 118) | def preprocess(self, in_, data):
    method deprocess (line 160) | def deprocess(self, in_, data):
    method set_transpose (line 183) | def set_transpose(self, in_, order):
    method set_channel_swap (line 199) | def set_channel_swap(self, in_, order):
    method set_raw_scale (line 217) | def set_raw_scale(self, in_, scale):
    method set_mean (line 232) | def set_mean(self, in_, mean):
    method set_input_scale (line 258) | def set_input_scale(self, in_, scale):
  function load_image (line 275) | def load_image(filename, color=True):
  function resize_image (line 302) | def resize_image(im, new_dims, interp_order=1):
  function oversample (line 337) | def oversample(images, crop_dims):

FILE: python/caffe/net_spec.py
  function param_name_dict (line 28) | def param_name_dict():
  function to_proto (line 43) | def to_proto(*tops):
  function assign_proto (line 56) | def assign_proto(proto, name, val):
  class Top (line 82) | class Top(object):
    method __init__ (line 86) | def __init__(self, fn, n):
    method to_proto (line 90) | def to_proto(self):
    method _to_proto (line 96) | def _to_proto(self, layers, names, autonames):
  class Function (line 100) | class Function(object):
    method __init__ (line 104) | def __init__(self, type_name, inputs, params):
    method _get_name (line 117) | def _get_name(self, names, autonames):
    method _get_top_name (line 125) | def _get_top_name(self, top, names, autonames):
    method _to_proto (line 131) | def _to_proto(self, layers, names, autonames):
  class NetSpec (line 163) | class NetSpec(object):
    method __init__ (line 169) | def __init__(self):
    method __setattr__ (line 172) | def __setattr__(self, name, value):
    method __getattr__ (line 175) | def __getattr__(self, name):
    method to_proto (line 178) | def to_proto(self):
  class Layers (line 189) | class Layers(object):
    method __getattr__ (line 194) | def __getattr__(self, name):
  class Parameters (line 206) | class Parameters(object):
    method __getattr__ (line 211) | def __getattr__(self, name):

FILE: python/caffe/pycaffe.py
  function _Net_blobs (line 23) | def _Net_blobs(self):
  function _Net_blob_loss_weights (line 32) | def _Net_blob_loss_weights(self):
  function _Net_params (line 41) | def _Net_params(self):
  function _Net_inputs (line 53) | def _Net_inputs(self):
  function _Net_outputs (line 58) | def _Net_outputs(self):
  function _Net_forward (line 62) | def _Net_forward(self, blobs=None, start=None, end=None, **kwargs):
  function _Net_backward (line 111) | def _Net_backward(self, diffs=None, start=None, end=None, **kwargs):
  function _Net_forward_all (line 161) | def _Net_forward_all(self, blobs=None, **kwargs):
  function _Net_forward_backward_all (line 192) | def _Net_forward_backward_all(self, blobs=None, diffs=None, **kwargs):
  function _Net_set_input_arrays (line 237) | def _Net_set_input_arrays(self, data, labels):
  function _Net_batch (line 248) | def _Net_batch(self, blobs):

FILE: python/caffe/test/test_layer_type_list.py
  class TestLayerTypeList (line 5) | class TestLayerTypeList(unittest.TestCase):
    method test_standard_types (line 7) | def test_standard_types(self):

FILE: python/caffe/test/test_net.py
  function simple_net_file (line 10) | def simple_net_file(num_output):
  class TestNet (line 37) | class TestNet(unittest.TestCase):
    method setUp (line 38) | def setUp(self):
    method test_memory (line 48) | def test_memory(self):
    method test_forward_backward (line 62) | def test_forward_backward(self):
    method test_inputs_outputs (line 66) | def test_inputs_outputs(self):
    method test_save_and_read (line 70) | def test_save_and_read(self):

FILE: python/caffe/test/test_net_spec.py
  function lenet (line 7) | def lenet(batch_size):
  function anon_lenet (line 26) | def anon_lenet(batch_size):
  function silent_net (line 44) | def silent_net():
  class TestNetSpec (line 51) | class TestNetSpec(unittest.TestCase):
    method load_net (line 52) | def load_net(self, net_proto):
    method test_lenet (line 58) | def test_lenet(self):
    method test_zero_tops (line 76) | def test_zero_tops(self):

FILE: python/caffe/test/test_python_layer.py
  class SimpleLayer (line 9) | class SimpleLayer(caffe.Layer):
    method setup (line 12) | def setup(self, bottom, top):
    method reshape (line 15) | def reshape(self, bottom, top):
    method forward (line 18) | def forward(self, bottom, top):
    method backward (line 21) | def backward(self, top, propagate_down, bottom):
  class ExceptionLayer (line 25) | class ExceptionLayer(caffe.Layer):
    method setup (line 28) | def setup(self, bottom, top):
  class ParameterLayer (line 31) | class ParameterLayer(caffe.Layer):
    method setup (line 34) | def setup(self, bottom, top):
    method reshape (line 38) | def reshape(self, bottom, top):
    method forward (line 41) | def forward(self, bottom, top):
    method backward (line 44) | def backward(self, top, propagate_down, bottom):
  function python_net_file (line 47) | def python_net_file():
  function exception_net_file (line 60) | def exception_net_file():
  function parameter_net_file (line 70) | def parameter_net_file():
  class TestPythonLayer (line 80) | class TestPythonLayer(unittest.TestCase):
    method setUp (line 81) | def setUp(self):
    method test_forward (line 86) | def test_forward(self):
    method test_backward (line 93) | def test_backward(self):
    method test_reshape (line 100) | def test_reshape(self):
    method test_exception (line 108) | def test_exception(self):
    method test_parameter (line 113) | def test_parameter(self):

FILE: python/caffe/test/test_python_layer_with_param_str.py
  class SimpleParamLayer (line 9) | class SimpleParamLayer(caffe.Layer):
    method setup (line 12) | def setup(self, bottom, top):
    method reshape (line 18) | def reshape(self, bottom, top):
    method forward (line 21) | def forward(self, bottom, top):
    method backward (line 24) | def backward(self, top, propagate_down, bottom):
  function python_param_net_file (line 28) | def python_param_net_file():
  class TestLayerWithParam (line 41) | class TestLayerWithParam(unittest.TestCase):
    method setUp (line 42) | def setUp(self):
    method test_forward (line 47) | def test_forward(self):
    method test_backward (line 54) | def test_backward(self):

FILE: python/caffe/test/test_solver.py
  class TestSolver (line 11) | class TestSolver(unittest.TestCase):
    method setUp (line 12) | def setUp(self):
    method test_solve (line 35) | def test_solve(self):
    method test_net_memory (line 40) | def test_net_memory(self):

FILE: python/classify.py
  function main (line 17) | def main(argv):

FILE: python/detect.py
  function main (line 30) | def main(argv):

FILE: python/draw_net.py
  function parse_args (line 13) | def parse_args():
  function main (line 36) | def main():

FILE: scripts/cpp_lint.py
  function ParseNolintSuppressions (line 464) | def ParseNolintSuppressions(filename, raw_line, linenum, error):
  function ResetNolintSuppressions (line 495) | def ResetNolintSuppressions():
  function IsErrorSuppressedByNolint (line 500) | def IsErrorSuppressedByNolint(category, linenum):
  function Match (line 515) | def Match(pattern, s):
  function ReplaceAll (line 525) | def ReplaceAll(pattern, rep, s):
  function Search (line 543) | def Search(pattern, s):
  class _IncludeState (line 550) | class _IncludeState(dict):
    method __init__ (line 584) | def __init__(self):
    method ResetSection (line 588) | def ResetSection(self):
    method SetLastHeader (line 594) | def SetLastHeader(self, header_path):
    method CanonicalizeAlphabeticalOrder (line 597) | def CanonicalizeAlphabeticalOrder(self, header_path):
    method IsInAlphabeticalOrder (line 612) | def IsInAlphabeticalOrder(self, clean_lines, linenum, header_path):
    method CheckNextIncludeOrder (line 633) | def CheckNextIncludeOrder(self, header_type):
  class _CppLintState (line 687) | class _CppLintState(object):
    method __init__ (line 690) | def __init__(self):
    method SetOutputFormat (line 703) | def SetOutputFormat(self, output_format):
    method SetVerboseLevel (line 707) | def SetVerboseLevel(self, level):
    method SetCountingStyle (line 713) | def SetCountingStyle(self, counting_style):
    method SetFilters (line 717) | def SetFilters(self, filters):
    method ResetErrorCounts (line 742) | def ResetErrorCounts(self):
    method IncrementErrorCount (line 747) | def IncrementErrorCount(self, category):
    method PrintErrorCounts (line 757) | def PrintErrorCounts(self):
  function _OutputFormat (line 767) | def _OutputFormat():
  function _SetOutputFormat (line 772) | def _SetOutputFormat(output_format):
  function _VerboseLevel (line 777) | def _VerboseLevel():
  function _SetVerboseLevel (line 782) | def _SetVerboseLevel(level):
  function _SetCountingStyle (line 787) | def _SetCountingStyle(level):
  function _Filters (line 792) | def _Filters():
  function _SetFilters (line 797) | def _SetFilters(filters):
  class _FunctionState (line 810) | class _FunctionState(object):
    method __init__ (line 816) | def __init__(self):
    method Begin (line 821) | def Begin(self, function_name):
    method Count (line 831) | def Count(self):
    method Check (line 836) | def Check(self, error, filename, linenum):
    method End (line 861) | def End(self):
  class _IncludeError (line 866) | class _IncludeError(Exception):
  class FileInfo (line 871) | class FileInfo:
    method __init__ (line 878) | def __init__(self, filename):
    method FullName (line 881) | def FullName(self):
    method RepositoryName (line 885) | def RepositoryName(self):
    method Split (line 930) | def Split(self):
    method BaseName (line 944) | def BaseName(self):
    method Extension (line 948) | def Extension(self):
    method NoExtension (line 952) | def NoExtension(self):
    method IsSource (line 956) | def IsSource(self):
  function _ShouldPrintError (line 961) | def _ShouldPrintError(category, confidence, linenum):
  function Error (line 988) | def Error(filename, linenum, category, confidence, message):
  function IsCppString (line 1045) | def IsCppString(line):
  function CleanseRawStrings (line 1062) | def CleanseRawStrings(raw_lines):
  function FindNextMultiLineCommentStart (line 1123) | def FindNextMultiLineCommentStart(lines, lineix):
  function FindNextMultiLineCommentEnd (line 1134) | def FindNextMultiLineCommentEnd(lines, lineix):
  function RemoveMultiLineCommentsFromRange (line 1143) | def RemoveMultiLineCommentsFromRange(lines, begin, end):
  function RemoveMultiLineComments (line 1151) | def RemoveMultiLineComments(filename, lines, error):
  function CleanseComments (line 1167) | def CleanseComments(line):
  class CleansedLines (line 1183) | class CleansedLines(object):
    method __init__ (line 1192) | def __init__(self, lines):
    method NumLines (line 1204) | def NumLines(self):
    method _CollapseStrings (line 1209) | def _CollapseStrings(elided):
  function FindEndOfExpressionInLine (line 1230) | def FindEndOfExpressionInLine(line, startpos, depth, startchar, endchar):
  function CloseExpression (line 1254) | def CloseExpression(clean_lines, linenum, pos):
  function FindStartOfExpressionInLine (line 1300) | def FindStartOfExpressionInLine(line, endpos, depth, startchar, endchar):
  function ReverseCloseExpression (line 1327) | def ReverseCloseExpression(clean_lines, linenum, pos):
  function CheckForCopyright (line 1372) | def CheckForCopyright(filename, lines, error):
  function GetHeaderGuardCPPVariable (line 1384) | def GetHeaderGuardCPPVariable(filename):
  function CheckForHeaderGuard (line 1408) | def CheckForHeaderGuard(filename, lines, error):
  function CheckForBadCharacters (line 1483) | def CheckForBadCharacters(filename, lines, error):
  function CheckForNewlineAtEOF (line 1508) | def CheckForNewlineAtEOF(filename, lines, error):
  function CheckForMultilineCommentsAndStrings (line 1526) | def CheckForMultilineCommentsAndStrings(filename, clean_lines, linenum, ...
  function CheckCaffeAlternatives (line 1572) | def CheckCaffeAlternatives(filename, clean_lines, linenum, error):
  function CheckCaffeDataLayerSetUp (line 1595) | def CheckCaffeDataLayerSetUp(filename, clean_lines, linenum, error):
  function CheckCaffeRandom (line 1640) | def CheckCaffeRandom(filename, clean_lines, linenum, error):
  function CheckPosixThreading (line 1681) | def CheckPosixThreading(filename, clean_lines, linenum, error):
  function CheckVlogArguments (line 1708) | def CheckVlogArguments(filename, clean_lines, linenum, error):
  function CheckInvalidIncrement (line 1733) | def CheckInvalidIncrement(filename, clean_lines, linenum, error):
  class _BlockInfo (line 1755) | class _BlockInfo(object):
    method __init__ (line 1758) | def __init__(self, seen_open_brace):
    method CheckBegin (line 1763) | def CheckBegin(self, filename, clean_lines, linenum, error):
    method CheckEnd (line 1778) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _ClassInfo (line 1792) | class _ClassInfo(_BlockInfo):
    method __init__ (line 1795) | def __init__(self, name, class_or_struct, clean_lines, linenum):
    method CheckBegin (line 1829) | def CheckBegin(self, filename, clean_lines, linenum, error):
    method CheckEnd (line 1834) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _NamespaceInfo (line 1848) | class _NamespaceInfo(_BlockInfo):
    method __init__ (line 1851) | def __init__(self, name, linenum):
    method CheckEnd (line 1856) | def CheckEnd(self, filename, clean_lines, linenum, error):
  class _PreprocessorInfo (line 1902) | class _PreprocessorInfo(object):
    method __init__ (line 1905) | def __init__(self, stack_before_if):
  class _NestingState (line 1916) | class _NestingState(object):
    method __init__ (line 1919) | def __init__(self):
    method SeenOpenBrace (line 1931) | def SeenOpenBrace(self):
    method InNamespaceBody (line 1940) | def InNamespaceBody(self):
    method UpdatePreprocessor (line 1948) | def UpdatePreprocessor(self, line):
    method Update (line 2004) | def Update(self, filename, clean_lines, linenum, error):
    method InnermostClass (line 2160) | def InnermostClass(self):
    method CheckCompletedBlocks (line 2172) | def CheckCompletedBlocks(self, filename, error):
  function CheckForNonStandardConstructs (line 2194) | def CheckForNonStandardConstructs(filename, clean_lines, linenum,
  function CheckSpacingForFunctionCall (line 2301) | def CheckSpacingForFunctionCall(filename, line, linenum, error):
  function IsBlankLine (line 2369) | def IsBlankLine(line):
  function CheckForFunctionLengths (line 2384) | def CheckForFunctionLengths(filename, clean_lines, linenum,
  function CheckComment (line 2457) | def CheckComment(comment, filename, linenum, error):
  function CheckAccess (line 2486) | def CheckAccess(filename, clean_lines, linenum, nesting_state, error):
  function FindNextMatchingAngleBracket (line 2517) | def FindNextMatchingAngleBracket(clean_lines, linenum, init_suffix):
  function FindPreviousMatchingAngleBracket (line 2586) | def FindPreviousMatchingAngleBracket(clean_lines, linenum, init_prefix):
  function CheckSpacing (line 2643) | def CheckSpacing(filename, clean_lines, linenum, nesting_state, error):
  function CheckSectionSpacing (line 2991) | def CheckSectionSpacing(filename, clean_lines, class_info, linenum, error):
  function GetPreviousNonBlankLine (line 3046) | def GetPreviousNonBlankLine(clean_lines, linenum):
  function CheckBraces (line 3069) | def CheckBraces(filename, clean_lines, linenum, error):
  function CheckEmptyBlockBody (line 3243) | def CheckEmptyBlockBody(filename, clean_lines, linenum, error):
  function CheckCheck (line 3278) | def CheckCheck(filename, clean_lines, linenum, error):
  function CheckAltTokens (line 3405) | def CheckAltTokens(filename, clean_lines, linenum, error):
  function GetLineWidth (line 3437) | def GetLineWidth(line):
  function CheckStyle (line 3459) | def CheckStyle(filename, clean_lines, linenum, file_extension, nesting_s...
  function _DropCommonSuffixes (line 3576) | def _DropCommonSuffixes(filename):
  function _IsTestFilename (line 3603) | def _IsTestFilename(filename):
  function _ClassifyInclude (line 3620) | def _ClassifyInclude(fileinfo, include, is_system):
  function CheckIncludeLine (line 3680) | def CheckIncludeLine(filename, clean_lines, linenum, include_state, error):
  function _GetTextInside (line 3752) | def _GetTextInside(text, start_pattern):
  function CheckLanguage (line 3834) | def CheckLanguage(filename, clean_lines, linenum, file_extension,
  function CheckForNonConstReference (line 4134) | def CheckForNonConstReference(filename, clean_lines, linenum,
  function CheckCStyleCast (line 4247) | def CheckCStyleCast(filename, linenum, line, raw_line, cast_type, pattern,
  function FilesBelongToSameModule (line 4399) | def FilesBelongToSameModule(filename_cc, filename_h):
  function UpdateIncludeState (line 4454) | def UpdateIncludeState(filename, include_state, io=codecs):
  function CheckForIncludeWhatYouUse (line 4483) | def CheckForIncludeWhatYouUse(filename, clean_lines, include_state, error,
  function CheckMakePairUsesDeduction (line 4579) | def CheckMakePairUsesDeduction(filename, clean_lines, linenum, error):
  function ProcessLine (line 4600) | def ProcessLine(filename, file_extension, clean_lines, line,
  function ProcessFileData (line 4644) | def ProcessFileData(filename, file_extension, lines, error,
  function ProcessFile (line 4689) | def ProcessFile(filename, vlevel, extra_check_functions=[]):
  function PrintUsage (line 4757) | def PrintUsage(message):
  function PrintCategories (line 4770) | def PrintCategories():
  function ParseArguments (line 4779) | def ParseArguments(args):
  function main (line 4849) | def main():

FILE: scripts/download_model_binary.py
  function reporthook (line 13) | def reporthook(count, block_size, total_size):
  function parse_readme_frontmatter (line 30) | def parse_readme_frontmatter(dirname):
  function valid_dirname (line 41) | def valid_dirname(dirname):
  function model_checks_out (line 62) | def model_checks_out(filename=model_filename, sha1=frontmatter['sha1']):

FILE: src/caffe/blob.cpp
  type caffe (line 9) | namespace caffe {
    function Dtype (line 71) | const Dtype* Blob<Dtype>::cpu_data() const {
    function Dtype (line 83) | const Dtype* Blob<Dtype>::gpu_data() const {
    function Dtype (line 89) | const Dtype* Blob<Dtype>::cpu_diff() const {
    function Dtype (line 95) | const Dtype* Blob<Dtype>::gpu_diff() const {
    function Dtype (line 101) | Dtype* Blob<Dtype>::mutable_cpu_data() {
    function Dtype (line 107) | Dtype* Blob<Dtype>::mutable_gpu_data() {
    function Dtype (line 113) | Dtype* Blob<Dtype>::mutable_cpu_diff() {
    function Dtype (line 119) | Dtype* Blob<Dtype>::mutable_gpu_diff() {
    function Dtype (line 179) | Dtype Blob<Dtype>::asum_data() const {
    function Dtype (line 214) | Dtype Blob<Dtype>::asum_diff() const {
    function Dtype (line 249) | Dtype Blob<Dtype>::sumsq_data() const {
    function Dtype (line 286) | Dtype Blob<Dtype>::sumsq_diff() const {
    class Blob<int> (line 526) | class Blob<int>
    class Blob<unsigned int> (line 527) | class Blob<unsigned int>

FILE: src/caffe/common.cpp
  type caffe (line 10) | namespace caffe {
    function Caffe (line 15) | Caffe& Caffe::Get() {
    function cluster_seedgen (line 23) | int64_t cluster_seedgen(void) {
    function GlobalInit (line 43) | void GlobalInit(int* pargc, char*** pargv) {
    class Caffe::RNG::Generator (line 74) | class Caffe::RNG::Generator {
      method Generator (line 76) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 77) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
      method Generator (line 198) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 199) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
    class Caffe::RNG::Generator (line 196) | class Caffe::RNG::Generator {
      method Generator (line 76) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 77) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}
      method Generator (line 198) | Generator() : rng_(new caffe::rng_t(cluster_seedgen())) {}
      method Generator (line 199) | explicit Generator(unsigned int seed) : rng_(new caffe::rng_t(seed)) {}

FILE: src/caffe/data_reader.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/data_transformer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/internal_thread.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layer.cpp
  type caffe (line 4) | namespace caffe {

FILE: src/caffe/layer_factory.cpp
  type caffe (line 17) | namespace caffe {
    function GetConvolutionLayer (line 21) | shared_ptr<Layer<Dtype> > GetConvolutionLayer(
    function GetPoolingLayer (line 45) | shared_ptr<Layer<Dtype> > GetPoolingLayer(const LayerParameter& param) {
    function GetReLULayer (line 75) | shared_ptr<Layer<Dtype> > GetReLULayer(const LayerParameter& param) {
    function GetSigmoidLayer (line 98) | shared_ptr<Layer<Dtype> > GetSigmoidLayer(const LayerParameter& param) {
    function GetSoftmaxLayer (line 121) | shared_ptr<Layer<Dtype> > GetSoftmaxLayer(const LayerParameter& param) {
    function GetTanHLayer (line 144) | shared_ptr<Layer<Dtype> > GetTanHLayer(const LayerParameter& param) {
    function GetPythonLayer (line 167) | shared_ptr<Layer<Dtype> > GetPythonLayer(const LayerParameter& param) {

FILE: src/caffe/layers/absval_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/accuracy_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/argmax_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/base_conv_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/base_data_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/bnll_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/concat_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/contrastive_loss_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/conv_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/cudnn_conv_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/cudnn_pooling_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/cudnn_relu_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/cudnn_sigmoid_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/cudnn_softmax_layer.cpp
  type caffe (line 12) | namespace caffe {

FILE: src/caffe/layers/cudnn_tanh_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/data_heatmap.cpp
  type caffe (line 29) | namespace caffe

FILE: src/caffe/layers/data_layer.cpp
  type caffe (line 15) | namespace caffe {

FILE: src/caffe/layers/deconv_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/dropout_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/dummy_data_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/eltwise_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/embed_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/euclidean_loss_heatmap_layer.cpp
  type caffe (line 20) | namespace caffe {

FILE: src/caffe/layers/euclidean_loss_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/exp_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/filter_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/flatten_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/hdf5_data_layer.cpp
  type caffe (line 21) | namespace caffe {

FILE: src/caffe/layers/hdf5_output_layer.cpp
  type caffe (line 12) | namespace caffe {

FILE: src/caffe/layers/hinge_loss_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/im2col_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/image_data_layer.cpp
  type caffe (line 16) | namespace caffe {

FILE: src/caffe/layers/infogain_loss_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/inner_product_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/log_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/loss_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/lrn_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/memory_data_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/multinomial_logistic_loss_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/mvn_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/neuron_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/pooling_layer.cpp
  type caffe (line 11) | namespace caffe {

FILE: src/caffe/layers/power_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/prelu_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/reduction_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/relu_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/reshape_layer.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/layers/sigmoid_cross_entropy_loss_layer.cpp
  type caffe (line 9) | namespace caffe {

FILE: src/caffe/layers/sigmoid_layer.cpp
  type caffe (line 8) | namespace caffe {
    function Dtype (line 11) | inline Dtype sigmoid(Dtype x) {

FILE: src/caffe/layers/silence_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/slice_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/softmax_layer.cpp
  type caffe (line 8) | namespace caffe {

FILE: src/caffe/layers/softmax_loss_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/split_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/spp_layer.cpp
  type caffe (line 11) | namespace caffe {
    function LayerParameter (line 17) | LayerParameter SPPLayer<Dtype>::GetPoolingParam(const int pyramid_level,

FILE: src/caffe/layers/tanh_layer.cpp
  type caffe (line 10) | namespace caffe {

FILE: src/caffe/layers/threshold_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/tile_layer.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/layers/window_data_layer.cpp
  type caffe (line 26) | namespace caffe {

FILE: src/caffe/net.cpp
  type caffe (line 22) | namespace caffe {
    function Dtype (line 588) | Dtype Net<Dtype>::ForwardFromTo(int start, int end) {
    function Dtype (line 607) | Dtype Net<Dtype>::ForwardFrom(int start) {
    function Dtype (line 612) | Dtype Net<Dtype>::ForwardTo(int end) {
    function string (line 637) | string Net<Dtype>::Forward(const string& input_blob_protos, Dtype* los...

FILE: src/caffe/parallel.cpp
  type caffe (line 19) | namespace caffe {
    type Op (line 21) | enum Op {
    function apply_buffers (line 30) | static void apply_buffers(const vector<Blob<Dtype>*>& blobs,
    function total_size (line 64) | static size_t total_size(const vector<Blob<Dtype>*>& params) {

FILE: src/caffe/solver.cpp
  type caffe (line 18) | namespace caffe {
    function string (line 438) | string Solver<Dtype>::SnapshotFilename(const string extension) {
    function string (line 447) | string Solver<Dtype>::SnapshotToBinaryProto() {
    function string (line 457) | string Solver<Dtype>::SnapshotToHDF5() {
    function Dtype (line 492) | Dtype SGDSolver<Dtype>::GetLearningRate() {

FILE: src/caffe/syncedmem.cpp
  type caffe (line 7) | namespace caffe {

FILE: src/caffe/test/test_accuracy_layer.cpp
  type caffe (line 16) | namespace caffe {
    class AccuracyLayerTest (line 19) | class AccuracyLayerTest : public CPUDeviceTest<Dtype> {
      method AccuracyLayerTest (line 21) | AccuracyLayerTest()
      method FillBottoms (line 42) | virtual void FillBottoms() {
    function TYPED_TEST (line 76) | TYPED_TEST(AccuracyLayerTest, TestSetup) {
    function TYPED_TEST (line 86) | TYPED_TEST(AccuracyLayerTest, TestSetupTopK) {
    function TYPED_TEST (line 99) | TYPED_TEST(AccuracyLayerTest, TestSetupOutputPerClass) {
    function TYPED_TEST (line 113) | TYPED_TEST(AccuracyLayerTest, TestForwardCPU) {
    function TYPED_TEST (line 139) | TYPED_TEST(AccuracyLayerTest, TestForwardWithSpatialAxes) {
    function TYPED_TEST (line 182) | TYPED_TEST(AccuracyLayerTest, TestForwardIgnoreLabel) {
    function TYPED_TEST (line 220) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUTopK) {
    function TYPED_TEST (line 251) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClass) {
    function TYPED_TEST (line 289) | TYPED_TEST(AccuracyLayerTest, TestForwardCPUPerClassWithIgnoreLabel) {

FILE: src/caffe/test/test_argmax_layer.cpp
  type caffe (line 13) | namespace caffe {
    class ArgMaxLayerTest (line 16) | class ArgMaxLayerTest : public CPUDeviceTest<Dtype> {
      method ArgMaxLayerTest (line 18) | ArgMaxLayerTest()
    function TYPED_TEST (line 40) | TYPED_TEST(ArgMaxLayerTest, TestSetup) {
    function TYPED_TEST (line 48) | TYPED_TEST(ArgMaxLayerTest, TestSetupMaxVal) {
    function TYPED_TEST (line 58) | TYPED_TEST(ArgMaxLayerTest, TestCPU) {
    function TYPED_TEST (line 81) | TYPED_TEST(ArgMaxLayerTest, TestCPUMaxVal) {
    function TYPED_TEST (line 107) | TYPED_TEST(ArgMaxLayerTest, TestCPUTopK) {
    function TYPED_TEST (line 136) | TYPED_TEST(ArgMaxLayerTest, TestCPUMaxValTopK) {

FILE: src/caffe/test/test_benchmark.cpp
  type caffe (line 10) | namespace caffe {
    class BenchmarkTest (line 15) | class BenchmarkTest : public MultiDeviceTest<TypeParam> {}
    function TYPED_TEST (line 19) | TYPED_TEST(BenchmarkTest, TestTimerConstructor) {
    function TYPED_TEST (line 26) | TYPED_TEST(BenchmarkTest, TestTimerStart) {
    function TYPED_TEST (line 43) | TYPED_TEST(BenchmarkTest, TestTimerStop) {
    function TYPED_TEST (line 60) | TYPED_TEST(BenchmarkTest, TestTimerMilliSeconds) {
    function TYPED_TEST (line 75) | TYPED_TEST(BenchmarkTest, TestTimerSeconds) {

FILE: src/caffe/test/test_blob.cpp
  type caffe (line 12) | namespace caffe {
    class BlobSimpleTest (line 15) | class BlobSimpleTest : public ::testing::Test {
      method BlobSimpleTest (line 17) | BlobSimpleTest()
    function TYPED_TEST (line 27) | TYPED_TEST(BlobSimpleTest, TestInitialization) {
    function TYPED_TEST (line 39) | TYPED_TEST(BlobSimpleTest, TestPointersCPUGPU) {
    function TYPED_TEST (line 46) | TYPED_TEST(BlobSimpleTest, TestReshape) {
    function TYPED_TEST (line 55) | TYPED_TEST(BlobSimpleTest, TestLegacyBlobProtoShapeEquals) {
    class BlobMathTest (line 109) | class BlobMathTest : public MultiDeviceTest<TypeParam> {
      method BlobMathTest (line 112) | BlobMathTest()
    function TYPED_TEST (line 123) | TYPED_TEST(BlobMathTest, TestSumOfSquares) {
    function TYPED_TEST (line 178) | TYPED_TEST(BlobMathTest, TestAsum) {
    function TYPED_TEST (line 232) | TYPED_TEST(BlobMathTest, TestScaleData) {

FILE: src/caffe/test/test_caffe_main.cpp
  type caffe (line 7) | namespace caffe {
  function main (line 17) | int main(int argc, char** argv) {

FILE: src/caffe/test/test_common.cpp
  type caffe (line 11) | namespace caffe {
    class CommonTest (line 13) | class CommonTest : public ::testing::Test {}
    function TEST_F (line 17) | TEST_F(CommonTest, TestCublasHandlerGPU) {
    function TEST_F (line 25) | TEST_F(CommonTest, TestBrewMode) {
    function TEST_F (line 32) | TEST_F(CommonTest, TestRandSeedCPU) {
    function TEST_F (line 49) | TEST_F(CommonTest, TestRandSeedGPU) {

FILE: src/caffe/test/test_concat_layer.cpp
  type caffe (line 14) | namespace caffe {
    class ConcatLayerTest (line 17) | class ConcatLayerTest : public MultiDeviceTest<TypeParam> {
      method ConcatLayerTest (line 21) | ConcatLayerTest()
      method SetUp (line 26) | virtual void SetUp() {
    function TYPED_TEST (line 61) | TYPED_TEST(ConcatLayerTest, TestSetupNum) {
    function TYPED_TEST (line 74) | TYPED_TEST(ConcatLayerTest, TestSetupChannels) {
    function TYPED_TEST (line 86) | TYPED_TEST(ConcatLayerTest, TestSetupChannelsNegativeIndexing) {
    function TYPED_TEST (line 102) | TYPED_TEST(ConcatLayerTest, TestForwardTrivial) {
    function TYPED_TEST (line 115) | TYPED_TEST(ConcatLayerTest, TestForwardNum) {
    function TYPED_TEST (line 144) | TYPED_TEST(ConcatLayerTest, TestForwardChannels) {
    function TYPED_TEST (line 170) | TYPED_TEST(ConcatLayerTest, TestGradientTrivial) {
    function TYPED_TEST (line 180) | TYPED_TEST(ConcatLayerTest, TestGradientNum) {
    function TYPED_TEST (line 190) | TYPED_TEST(ConcatLayerTest, TestGradientChannels) {
    function TYPED_TEST (line 199) | TYPED_TEST(ConcatLayerTest, TestGradientChannelsBottomOneOnly) {

FILE: src/caffe/test/test_contrastive_loss_layer.cpp
  type caffe (line 17) | namespace caffe {
    class ContrastiveLossLayerTest (line 20) | class ContrastiveLossLayerTest : public MultiDeviceTest<TypeParam> {
      method ContrastiveLossLayerTest (line 24) | ContrastiveLossLayerTest()
    function TYPED_TEST (line 61) | TYPED_TEST(ContrastiveLossLayerTest, TestForward) {
    function TYPED_TEST (line 90) | TYPED_TEST(ContrastiveLossLayerTest, TestGradient) {
    function TYPED_TEST (line 103) | TYPED_TEST(ContrastiveLossLayerTest, TestForwardLegacy) {
    function TYPED_TEST (line 132) | TYPED_TEST(ContrastiveLossLayerTest, TestGradientLegacy) {

FILE: src/caffe/test/test_convolution_layer.cpp
  type caffe (line 14) | namespace caffe {
    function caffe_conv (line 19) | void caffe_conv(const Blob<Dtype>* in, ConvolutionParameter* conv_param,
    class ConvolutionLayerTest (line 104) | class ConvolutionLayerTest : public MultiDeviceTest<TypeParam> {
      method ConvolutionLayerTest (line 108) | ConvolutionLayerTest()
      method SetUp (line 113) | virtual void SetUp() {
    function TYPED_TEST (line 148) | TYPED_TEST(ConvolutionLayerTest, TestSetup) {
    function TYPED_TEST (line 184) | TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolution) {
    function TYPED_TEST (line 220) | TYPED_TEST(ConvolutionLayerTest, Test1x1Convolution) {
    function TYPED_TEST (line 247) | TYPED_TEST(ConvolutionLayerTest, TestSimpleConvolutionGroup) {
    function TYPED_TEST (line 275) | TYPED_TEST(ConvolutionLayerTest, TestSobelConvolution) {
    function TYPED_TEST (line 371) | TYPED_TEST(ConvolutionLayerTest, TestGradient) {
    function TYPED_TEST (line 389) | TYPED_TEST(ConvolutionLayerTest, Test1x1Gradient) {
    function TYPED_TEST (line 407) | TYPED_TEST(ConvolutionLayerTest, TestGradientGroup) {
    class CuDNNConvolutionLayerTest (line 427) | class CuDNNConvolutionLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNConvolutionLayerTest (line 429) | CuDNNConvolutionLayerTest()
      method SetUp (line 434) | virtual void SetUp() {
    function TYPED_TEST (line 469) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSetupCuDNN) {
    function TYPED_TEST (line 506) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionCuDNN) {
    function TYPED_TEST (line 541) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSimpleConvolutionGroupCuDNN) {
    function TYPED_TEST (line 568) | TYPED_TEST(CuDNNConvolutionLayerTest, TestSobelConvolutionCuDNN) {
    function TYPED_TEST (line 664) | TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientCuDNN) {
    function TYPED_TEST (line 681) | TYPED_TEST(CuDNNConvolutionLayerTest, TestGradientGroupCuDNN) {

FILE: src/caffe/test/test_data_layer.cpp
  type caffe (line 17) | namespace caffe {
    class DataLayerTest (line 22) | class DataLayerTest : public MultiDeviceTest<TypeParam> {
      method DataLayerTest (line 26) | DataLayerTest()
      method SetUp (line 31) | virtual void SetUp() {
      method Fill (line 42) | void Fill(const bool unique_pixels, DataParameter_DB backend) {
      method TestRead (line 69) | void TestRead() {
      method TestReshape (line 107) | void TestReshape(DataParameter_DB backend) {
      method TestReadCrop (line 172) | void TestReadCrop(Phase phase) {
      method TestReadCropTrainSequenceSeeded (line 226) | void TestReadCropTrainSequenceSeeded() {
      method TestReadCropTrainSequenceUnseeded (line 281) | void TestReadCropTrainSequenceUnseeded() {
    function TYPED_TEST (line 351) | TYPED_TEST(DataLayerTest, TestReadLevelDB) {
    function TYPED_TEST (line 357) | TYPED_TEST(DataLayerTest, TestReshapeLevelDB) {
    function TYPED_TEST (line 361) | TYPED_TEST(DataLayerTest, TestReadCropTrainLevelDB) {
    function TYPED_TEST (line 369) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededLevelDB) {
    function TYPED_TEST (line 377) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededLevelDB) {
    function TYPED_TEST (line 383) | TYPED_TEST(DataLayerTest, TestReadCropTestLevelDB) {
    function TYPED_TEST (line 389) | TYPED_TEST(DataLayerTest, TestReadLMDB) {
    function TYPED_TEST (line 395) | TYPED_TEST(DataLayerTest, TestReshapeLMDB) {
    function TYPED_TEST (line 399) | TYPED_TEST(DataLayerTest, TestReadCropTrainLMDB) {
    function TYPED_TEST (line 407) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceSeededLMDB) {
    function TYPED_TEST (line 415) | TYPED_TEST(DataLayerTest, TestReadCropTrainSequenceUnseededLMDB) {
    function TYPED_TEST (line 421) | TYPED_TEST(DataLayerTest, TestReadCropTestLMDB) {

FILE: src/caffe/test/test_data_transformer.cpp
  type caffe (line 16) | namespace caffe {
    function FillDatum (line 18) | void FillDatum(const int label, const int channels, const int height,
    class DataTransformTest (line 33) | class DataTransformTest : public ::testing::Test {
      method DataTransformTest (line 35) | DataTransformTest()
      method NumSequenceMatches (line 39) | int NumSequenceMatches(const TransformationParameter transform_param,
    function TYPED_TEST (line 83) | TYPED_TEST(DataTransformTest, TestEmptyTransform) {
    function TYPED_TEST (line 107) | TYPED_TEST(DataTransformTest, TestEmptyTransformUniquePixels) {
    function TYPED_TEST (line 131) | TYPED_TEST(DataTransformTest, TestCropSize) {
    function TYPED_TEST (line 160) | TYPED_TEST(DataTransformTest, TestCropTrain) {
    function TYPED_TEST (line 177) | TYPED_TEST(DataTransformTest, TestCropTest) {
    function TYPED_TEST (line 194) | TYPED_TEST(DataTransformTest, TestMirrorTrain) {
    function TYPED_TEST (line 210) | TYPED_TEST(DataTransformTest, TestMirrorTest) {
    function TYPED_TEST (line 226) | TYPED_TEST(DataTransformTest, TestCropMirrorTrain) {
    function TYPED_TEST (line 248) | TYPED_TEST(DataTransformTest, TestCropMirrorTest) {
    function TYPED_TEST (line 270) | TYPED_TEST(DataTransformTest, TestMeanValue) {
    function TYPED_TEST (line 292) | TYPED_TEST(DataTransformTest, TestMeanValues) {
    function TYPED_TEST (line 317) | TYPED_TEST(DataTransformTest, TestMeanFile) {

FILE: src/caffe/test/test_db.cpp
  type caffe (line 13) | namespace caffe {
    class DBTest (line 18) | class DBTest : public ::testing::Test {
      method DBTest (line 20) | DBTest()
      method SetUp (line 24) | virtual void SetUp() {
    type TypeLevelDB (line 49) | struct TypeLevelDB {
    type TypeLMDB (line 54) | struct TypeLMDB {
    function TYPED_TEST (line 64) | TYPED_TEST(DBTest, TestGetDB) {
    function TYPED_TEST (line 68) | TYPED_TEST(DBTest, TestNext) {
    function TYPED_TEST (line 79) | TYPED_TEST(DBTest, TestSeekToFirst) {
    function TYPED_TEST (line 95) | TYPED_TEST(DBTest, TestKeyValue) {
    function TYPED_TEST (line 119) | TYPED_TEST(DBTest, TestWrite) {

FILE: src/caffe/test/test_deconvolution_layer.cpp
  type caffe (line 14) | namespace caffe {
    class DeconvolutionLayerTest (line 19) | class DeconvolutionLayerTest : public MultiDeviceTest<TypeParam> {
      method DeconvolutionLayerTest (line 23) | DeconvolutionLayerTest()
      method SetUp (line 28) | virtual void SetUp() {
    function TYPED_TEST (line 56) | TYPED_TEST(DeconvolutionLayerTest, TestSetup) {
    function TYPED_TEST (line 92) | TYPED_TEST(DeconvolutionLayerTest, TestSimpleDeconvolution) {
    function TYPED_TEST (line 140) | TYPED_TEST(DeconvolutionLayerTest, TestGradient) {

FILE: src/caffe/test/test_dummy_data_layer.cpp
  type caffe (line 13) | namespace caffe {
    class DummyDataLayerTest (line 16) | class DummyDataLayerTest : public CPUDeviceTest<Dtype> {
      method DummyDataLayerTest (line 18) | DummyDataLayerTest()
      method SetUp (line 23) | virtual void SetUp() {
    function TYPED_TEST (line 46) | TYPED_TEST(DummyDataLayerTest, TestOneTopConstant) {
    function TYPED_TEST (line 75) | TYPED_TEST(DummyDataLayerTest, TestTwoTopConstant) {
    function TYPED_TEST (line 113) | TYPED_TEST(DummyDataLayerTest, TestThreeTopConstantGaussianConstant) {

FILE: src/caffe/test/test_eltwise_layer.cpp
  type caffe (line 14) | namespace caffe {
    class EltwiseLayerTest (line 17) | class EltwiseLayerTest : public MultiDeviceTest<TypeParam> {
      method EltwiseLayerTest (line 21) | EltwiseLayerTest()
    function TYPED_TEST (line 54) | TYPED_TEST(EltwiseLayerTest, TestSetUp) {
    function TYPED_TEST (line 68) | TYPED_TEST(EltwiseLayerTest, TestProd) {
    function TYPED_TEST (line 87) | TYPED_TEST(EltwiseLayerTest, TestSum) {
    function TYPED_TEST (line 106) | TYPED_TEST(EltwiseLayerTest, TestSumCoeff) {
    function TYPED_TEST (line 129) | TYPED_TEST(EltwiseLayerTest, TestStableProdGradient) {
    function TYPED_TEST (line 141) | TYPED_TEST(EltwiseLayerTest, TestUnstableProdGradient) {
    function TYPED_TEST (line 153) | TYPED_TEST(EltwiseLayerTest, TestSumGradient) {
    function TYPED_TEST (line 164) | TYPED_TEST(EltwiseLayerTest, TestSumCoeffGradient) {
    function TYPED_TEST (line 178) | TYPED_TEST(EltwiseLayerTest, TestMax) {
    function TYPED_TEST (line 198) | TYPED_TEST(EltwiseLayerTest, TestMaxGradient) {

FILE: src/caffe/test/test_embed_layer.cpp
  type caffe (line 14) | namespace caffe {
    class EmbedLayerTest (line 21) | class EmbedLayerTest : public MultiDeviceTest<TypeParam> {
      method EmbedLayerTest (line 24) | EmbedLayerTest()
    function TYPED_TEST (line 43) | TYPED_TEST(EmbedLayerTest, TestSetUp) {
    function TYPED_TEST (line 59) | TYPED_TEST(EmbedLayerTest, TestForward) {
    function TYPED_TEST (line 98) | TYPED_TEST(EmbedLayerTest, TestForwardWithBias) {
    function TYPED_TEST (line 142) | TYPED_TEST(EmbedLayerTest, TestGradient) {
    function TYPED_TEST (line 162) | TYPED_TEST(EmbedLayerTest, TestGradientWithBias) {

FILE: src/caffe/test/test_euclidean_loss_layer.cpp
  type caffe (line 16) | namespace caffe {
    class EuclideanLossLayerTest (line 19) | class EuclideanLossLayerTest : public MultiDeviceTest<TypeParam> {
      method EuclideanLossLayerTest (line 23) | EuclideanLossLayerTest()
      method TestForward (line 42) | void TestForward() {
    function TYPED_TEST (line 75) | TYPED_TEST(EuclideanLossLayerTest, TestForward) {
    function TYPED_TEST (line 79) | TYPED_TEST(EuclideanLossLayerTest, TestGradient) {

FILE: src/caffe/test/test_filler.cpp
  type caffe (line 9) | namespace caffe {
    class ConstantFillerTest (line 12) | class ConstantFillerTest : public ::testing::Test {
      method ConstantFillerTest (line 14) | ConstantFillerTest()
    function TYPED_TEST (line 29) | TYPED_TEST(ConstantFillerTest, TestFill) {
    class UniformFillerTest (line 40) | class UniformFillerTest : public ::testing::Test {
      method UniformFillerTest (line 42) | UniformFillerTest()
    function TYPED_TEST (line 58) | TYPED_TEST(UniformFillerTest, TestFill) {
    class PositiveUnitballFillerTest (line 69) | class PositiveUnitballFillerTest : public ::testing::Test {
      method PositiveUnitballFillerTest (line 71) | PositiveUnitballFillerTest()
    function TYPED_TEST (line 85) | TYPED_TEST(PositiveUnitballFillerTest, TestFill) {
    class GaussianFillerTest (line 106) | class GaussianFillerTest : public ::testing::Test {
      method GaussianFillerTest (line 108) | GaussianFillerTest()
    function TYPED_TEST (line 124) | TYPED_TEST(GaussianFillerTest, TestFill) {
    class XavierFillerTest (line 146) | class XavierFillerTest : public ::testing::Test {
      method XavierFillerTest (line 148) | XavierFillerTest()
      method test_params (line 152) | virtual void test_params(FillerParameter_VarianceNorm variance_norm,
    function TYPED_TEST (line 181) | TYPED_TEST(XavierFillerTest, TestFillFanIn) {
    function TYPED_TEST (line 185) | TYPED_TEST(XavierFillerTest, TestFillFanOut) {
    function TYPED_TEST (line 189) | TYPED_TEST(XavierFillerTest, TestFillAverage) {
    class MSRAFillerTest (line 195) | class MSRAFillerTest : public ::testing::Test {
      method MSRAFillerTest (line 197) | MSRAFillerTest()
      method test_params (line 201) | virtual void test_params(FillerParameter_VarianceNorm variance_norm,
    function TYPED_TEST (line 230) | TYPED_TEST(MSRAFillerTest, TestFillFanIn) {
    function TYPED_TEST (line 234) | TYPED_TEST(MSRAFillerTest, TestFillFanOut) {
    function TYPED_TEST (line 238) | TYPED_TEST(MSRAFillerTest, TestFillAverage) {

FILE: src/caffe/test/test_filter_layer.cpp
  type caffe (line 15) | namespace caffe {
    class FilterLayerTest (line 18) | class FilterLayerTest : public MultiDeviceTest<TypeParam> {
      method FilterLayerTest (line 22) | FilterLayerTest()
      method SetUp (line 28) | virtual void SetUp() {
    function TYPED_TEST (line 69) | TYPED_TEST(FilterLayerTest, TestReshape) {
    function TYPED_TEST (line 89) | TYPED_TEST(FilterLayerTest, TestForward) {
    function TYPED_TEST (line 117) | TYPED_TEST(FilterLayerTest, TestGradient) {

FILE: src/caffe/test/test_flatten_layer.cpp
  type caffe (line 14) | namespace caffe {
    class FlattenLayerTest (line 17) | class FlattenLayerTest : public MultiDeviceTest<TypeParam> {
      method FlattenLayerTest (line 20) | FlattenLayerTest()
    function TYPED_TEST (line 40) | TYPED_TEST(FlattenLayerTest, TestSetup) {
    function TYPED_TEST (line 50) | TYPED_TEST(FlattenLayerTest, TestSetupWithAxis) {
    function TYPED_TEST (line 62) | TYPED_TEST(FlattenLayerTest, TestSetupWithEndAxis) {
    function TYPED_TEST (line 74) | TYPED_TEST(FlattenLayerTest, TestSetupWithStartAndEndAxis) {
    function TYPED_TEST (line 86) | TYPED_TEST(FlattenLayerTest, TestForward) {
    function TYPED_TEST (line 100) | TYPED_TEST(FlattenLayerTest, TestGradient) {

FILE: src/caffe/test/test_gradient_based_solver.cpp
  type caffe (line 20) | namespace caffe {
    class GradientBasedSolverTest (line 23) | class GradientBasedSolverTest : public MultiDeviceTest<TypeParam> {
      method GradientBasedSolverTest (line 27) | GradientBasedSolverTest() :
      method InitSolverFromProtoString (line 53) | virtual void InitSolverFromProtoString(const string& proto) {
      method string (line 71) | string RunLeastSquaresSolver(const Dtype learning_rate,
      method ComputeLeastSquaresUpdate (line 226) | void ComputeLeastSquaresUpdate(const Dtype learning_rate,
      method CheckLeastSquaresUpdate (line 363) | void CheckLeastSquaresUpdate(
      method CheckAccumulation (line 413) | void CheckAccumulation(const Dtype kLearningRate, const Dtype kWeigh...
      method TestLeastSquaresUpdate (line 467) | void TestLeastSquaresUpdate(const Dtype learning_rate = 1.0,
      method TestSnapshot (line 504) | void TestSnapshot(const Dtype learning_rate = 1.0,
    class SGDSolverTest (line 577) | class SGDSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 581) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 585) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 592) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdate) {
    function TYPED_TEST (line 596) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateLROneHundredth) {
    function TYPED_TEST (line 602) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecay) {
    function TYPED_TEST (line 613) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithWeightDecayMultiIt...
    function TYPED_TEST (line 624) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentum) {
    function TYPED_TEST (line 635) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithMomentumMultiIter) {
    function TYPED_TEST (line 646) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverything) {
    function TYPED_TEST (line 657) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingShare) {
    function TYPED_TEST (line 669) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccum) {
    function TYPED_TEST (line 680) | TYPED_TEST(SGDSolverTest, TestLeastSquaresUpdateWithEverythingAccumSha...
    function TYPED_TEST (line 692) | TYPED_TEST(SGDSolverTest, TestSnapshot) {
    function TYPED_TEST (line 703) | TYPED_TEST(SGDSolverTest, TestSnapshotShare) {
    class AdaGradSolverTest (line 717) | class AdaGradSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 721) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 724) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 731) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdate) {
    function TYPED_TEST (line 735) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateLROneHundre...
    function TYPED_TEST (line 741) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithWeightD...
    function TYPED_TEST (line 748) | TYPED_TEST(AdaGradSolverTest, TestAdaGradLeastSquaresUpdateWithEveryth...
    function TYPED_TEST (line 759) | TYPED_TEST(AdaGradSolverTest,
    function TYPED_TEST (line 772) | TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 783) | TYPED_TEST(AdaGradSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 795) | TYPED_TEST(AdaGradSolverTest, TestSnapshot) {
    function TYPED_TEST (line 806) | TYPED_TEST(AdaGradSolverTest, TestSnapshotShare) {
    class NesterovSolverTest (line 820) | class NesterovSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 824) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 827) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 834) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdate) {
    function TYPED_TEST (line 838) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateLROneHund...
    function TYPED_TEST (line 844) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithWeigh...
    function TYPED_TEST (line 851) | TYPED_TEST(NesterovSolverTest,
    function TYPED_TEST (line 863) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithMomen...
    function TYPED_TEST (line 874) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithMomentumMulti...
    function TYPED_TEST (line 885) | TYPED_TEST(NesterovSolverTest, TestNesterovLeastSquaresUpdateWithEvery...
    function TYPED_TEST (line 896) | TYPED_TEST(NesterovSolverTest,
    function TYPED_TEST (line 909) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 920) | TYPED_TEST(NesterovSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 932) | TYPED_TEST(NesterovSolverTest, TestSnapshot) {
    function TYPED_TEST (line 943) | TYPED_TEST(NesterovSolverTest, TestSnapshotShare) {
    class AdaDeltaSolverTest (line 956) | class AdaDeltaSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 960) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 964) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 971) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdate) {
    function TYPED_TEST (line 977) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithWeigh...
    function TYPED_TEST (line 985) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithHalfM...
    function TYPED_TEST (line 996) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithMomen...
    function TYPED_TEST (line 1007) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithMomentumMulti...
    function TYPED_TEST (line 1018) | TYPED_TEST(AdaDeltaSolverTest, TestAdaDeltaLeastSquaresUpdateWithEvery...
    function TYPED_TEST (line 1029) | TYPED_TEST(AdaDeltaSolverTest,
    function TYPED_TEST (line 1042) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 1053) | TYPED_TEST(AdaDeltaSolverTest, TestLeastSquaresUpdateWithEverythingAcc...
    function TYPED_TEST (line 1065) | TYPED_TEST(AdaDeltaSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1076) | TYPED_TEST(AdaDeltaSolverTest, TestSnapshotShare) {
    class AdamSolverTest (line 1089) | class AdamSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 1093) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 1101) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 1108) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdate) {
    function TYPED_TEST (line 1116) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithWeightDecay) {
    function TYPED_TEST (line 1124) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverything) {
    function TYPED_TEST (line 1135) | TYPED_TEST(AdamSolverTest, TestAdamLeastSquaresUpdateWithEverythingSha...
    function TYPED_TEST (line 1147) | TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccum) {
    function TYPED_TEST (line 1158) | TYPED_TEST(AdamSolverTest, TestLeastSquaresUpdateWithEverythingAccumSh...
    function TYPED_TEST (line 1170) | TYPED_TEST(AdamSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1181) | TYPED_TEST(AdamSolverTest, TestSnapshotShare) {
    class RMSPropSolverTest (line 1194) | class RMSPropSolverTest : public GradientBasedSolverTest<TypeParam> {
      method InitSolver (line 1198) | virtual void InitSolver(const SolverParameter& param) {
      method SolverParameter_SolverType (line 1204) | virtual SolverParameter_SolverType solver_type() {
    function TYPED_TEST (line 1211) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithWeightD...
    function TYPED_TEST (line 1218) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithRmsDeca...
    function TYPED_TEST (line 1229) | TYPED_TEST(RMSPropSolverTest, TestRMSPropLeastSquaresUpdateWithEveryth...
    function TYPED_TEST (line 1240) | TYPED_TEST(RMSPropSolverTest,
    function TYPED_TEST (line 1253) | TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 1264) | TYPED_TEST(RMSPropSolverTest, TestLeastSquaresUpdateWithEverythingAccu...
    function TYPED_TEST (line 1276) | TYPED_TEST(RMSPropSolverTest, TestSnapshot) {
    function TYPED_TEST (line 1287) | TYPED_TEST(RMSPropSolverTest, TestSnapshotShare) {

FILE: src/caffe/test/test_hdf5_output_layer.cpp
  type caffe (line 15) | namespace caffe {
    class HDF5OutputLayerTest (line 18) | class HDF5OutputLayerTest : public MultiDeviceTest<TypeParam> {
      method HDF5OutputLayerTest (line 22) | HDF5OutputLayerTest()
    function TYPED_TEST (line 73) | TYPED_TEST(HDF5OutputLayerTest, TestForward) {

FILE: src/caffe/test/test_hdf5data_layer.cpp
  type caffe (line 14) | namespace caffe {
    class HDF5DataLayerTest (line 17) | class HDF5DataLayerTest : public MultiDeviceTest<TypeParam> {
      method HDF5DataLayerTest (line 21) | HDF5DataLayerTest()
      method SetUp (line 26) | virtual void SetUp() {
    function TYPED_TEST (line 54) | TYPED_TEST(HDF5DataLayerTest, TestRead) {

FILE: src/caffe/test/test_hinge_loss_layer.cpp
  type caffe (line 16) | namespace caffe {
    class HingeLossLayerTest (line 19) | class HingeLossLayerTest : public MultiDeviceTest<TypeParam> {
      method HingeLossLayerTest (line 23) | HingeLossLayerTest()
    function TYPED_TEST (line 55) | TYPED_TEST(HingeLossLayerTest, TestGradientL1) {
    function TYPED_TEST (line 64) | TYPED_TEST(HingeLossLayerTest, TestGradientL2) {

FILE: src/caffe/test/test_im2col_layer.cpp
  type caffe (line 14) | namespace caffe {
    class Im2colLayerTest (line 17) | class Im2colLayerTest : public MultiDeviceTest<TypeParam> {
      method Im2colLayerTest (line 20) | Im2colLayerTest()
    function TYPED_TEST (line 39) | TYPED_TEST(Im2colLayerTest, TestSetup) {
    function TYPED_TEST (line 54) | TYPED_TEST(Im2colLayerTest, TestForward) {
    function TYPED_TEST (line 71) | TYPED_TEST(Im2colLayerTest, TestGradient) {
    function TYPED_TEST (line 85) | TYPED_TEST(Im2colLayerTest, TestRect) {
    function TYPED_TEST (line 104) | TYPED_TEST(Im2colLayerTest, TestRectGradient) {

FILE: src/caffe/test/test_image_data_layer.cpp
  type caffe (line 16) | namespace caffe {
    class ImageDataLayerTest (line 19) | class ImageDataLayerTest : public MultiDeviceTest<TypeParam> {
      method ImageDataLayerTest (line 23) | ImageDataLayerTest()
      method SetUp (line 27) | virtual void SetUp() {
    function TYPED_TEST (line 64) | TYPED_TEST(ImageDataLayerTest, TestRead) {
    function TYPED_TEST (line 90) | TYPED_TEST(ImageDataLayerTest, TestResize) {
    function TYPED_TEST (line 118) | TYPED_TEST(ImageDataLayerTest, TestReshape) {
    function TYPED_TEST (line 145) | TYPED_TEST(ImageDataLayerTest, TestShuffle) {

FILE: src/caffe/test/test_infogain_loss_layer.cpp
  type caffe (line 16) | namespace caffe {
    class InfogainLossLayerTest (line 19) | class InfogainLossLayerTest : public MultiDeviceTest<TypeParam> {
      method InfogainLossLayerTest (line 23) | InfogainLossLayerTest()
    function TYPED_TEST (line 61) | TYPED_TEST(InfogainLossLayerTest, TestGradient) {

FILE: src/caffe/test/test_inner_product_layer.cpp
  type caffe (line 14) | namespace caffe {
    class InnerProductLayerTest (line 21) | class InnerProductLayerTest : public MultiDeviceTest<TypeParam> {
      method InnerProductLayerTest (line 24) | InnerProductLayerTest()
    function TYPED_TEST (line 48) | TYPED_TEST(InnerProductLayerTest, TestSetUp) {
    function TYPED_TEST (line 64) | TYPED_TEST(InnerProductLayerTest, TestForward) {
    function TYPED_TEST (line 95) | TYPED_TEST(InnerProductLayerTest, TestForwardNoBatch) {
    function TYPED_TEST (line 126) | TYPED_TEST(InnerProductLayerTest, TestGradient) {

FILE: src/caffe/test/test_internal_thread.cpp
  type caffe (line 9) | namespace caffe {
    class InternalThreadTest (line 12) | class InternalThreadTest : public ::testing::Test {}
    function TEST_F (line 14) | TEST_F(InternalThreadTest, TestStartAndExit) {
    class TestThreadA (line 23) | class TestThreadA : public InternalThread {
      method InternalThreadEntry (line 24) | void InternalThreadEntry() {
    class TestThreadB (line 29) | class TestThreadB : public InternalThread {
      method InternalThreadEntry (line 30) | void InternalThreadEntry() {
    function TEST_F (line 35) | TEST_F(InternalThreadTest, TestRandomSeed) {

FILE: src/caffe/test/test_io.cpp
  type caffe (line 15) | namespace caffe {
    class IOTest (line 17) | class IOTest : public ::testing::Test {}
    function ReadImageToDatumReference (line 19) | bool ReadImageToDatumReference(const string& filename, const int label,
    function TEST_F (line 64) | TEST_F(IOTest, TestReadImageToDatum) {
    function TEST_F (line 73) | TEST_F(IOTest, TestReadImageToDatumReference) {
    function TEST_F (line 92) | TEST_F(IOTest, TestReadImageToDatumReferenceResized) {
    function TEST_F (line 110) | TEST_F(IOTest, TestReadImageToDatumContent) {
    function TEST_F (line 131) | TEST_F(IOTest, TestReadImageToDatumContentGray) {
    function TEST_F (line 150) | TEST_F(IOTest, TestReadImageToDatumResized) {
    function TEST_F (line 160) | TEST_F(IOTest, TestReadImageToDatumResizedSquare) {
    function TEST_F (line 169) | TEST_F(IOTest, TestReadImageToDatumGray) {
    function TEST_F (line 179) | TEST_F(IOTest, TestReadImageToDatumResizedGray) {
    function TEST_F (line 189) | TEST_F(IOTest, TestReadImageToCVMat) {
    function TEST_F (line 197) | TEST_F(IOTest, TestReadImageToCVMatResized) {
    function TEST_F (line 205) | TEST_F(IOTest, TestReadImageToCVMatResizedSquare) {
    function TEST_F (line 213) | TEST_F(IOTest, TestReadImageToCVMatGray) {
    function TEST_F (line 222) | TEST_F(IOTest, TestReadImageToCVMatResizedGray) {
    function TEST_F (line 231) | TEST_F(IOTest, TestCVMatToDatum) {
    function TEST_F (line 241) | TEST_F(IOTest, TestCVMatToDatumContent) {
    function TEST_F (line 260) | TEST_F(IOTest, TestCVMatToDatumReference) {
    function TEST_F (line 279) | TEST_F(IOTest, TestReadFileToDatum) {
    function TEST_F (line 288) | TEST_F(IOTest, TestDecodeDatum) {
    function TEST_F (line 308) | TEST_F(IOTest, TestDecodeDatumToCVMat) {
    function TEST_F (line 322) | TEST_F(IOTest, TestDecodeDatumToCVMatContent) {
    function TEST_F (line 342) | TEST_F(IOTest, TestDecodeDatumNative) {
    function TEST_F (line 362) | TEST_F(IOTest, TestDecodeDatumToCVMatNative) {
    function TEST_F (line 372) | TEST_F(IOTest, TestDecodeDatumNativeGray) {
    function TEST_F (line 392) | TEST_F(IOTest, TestDecodeDatumToCVMatNativeGray) {
    function TEST_F (line 402) | TEST_F(IOTest, TestDecodeDatumToCVMatContentNative) {

FILE: src/caffe/test/test_layer_factory.cpp
  type caffe (line 15) | namespace caffe {
    class LayerFactoryTest (line 18) | class LayerFactoryTest : public MultiDeviceTest<TypeParam> {}
    function TYPED_TEST (line 22) | TYPED_TEST(LayerFactoryTest, TestCreateLayer) {

FILE: src/caffe/test/test_lrn_layer.cpp
  type caffe (line 18) | namespace caffe {
    class LRNLayerTest (line 21) | class LRNLayerTest : public MultiDeviceTest<TypeParam> {
      method LRNLayerTest (line 25) | LRNLayerTest()
      method SetUp (line 29) | virtual void SetUp() {
    function TYPED_TEST (line 115) | TYPED_TEST(LRNLayerTest, TestSetupAcrossChannels) {
    function TYPED_TEST (line 126) | TYPED_TEST(LRNLayerTest, TestForwardAcrossChannels) {
    function TYPED_TEST (line 141) | TYPED_TEST(LRNLayerTest, TestForwardAcrossChannelsLargeRegion) {
    function TYPED_TEST (line 157) | TYPED_TEST(LRNLayerTest, TestGradientAcrossChannels) {
    function TYPED_TEST (line 178) | TYPED_TEST(LRNLayerTest, TestGradientAcrossChannelsLargeRegion) {
    function TYPED_TEST (line 200) | TYPED_TEST(LRNLayerTest, TestSetupWithinChannel) {
    function TYPED_TEST (line 214) | TYPED_TEST(LRNLayerTest, TestForwardWithinChannel) {
    function TYPED_TEST (line 232) | TYPED_TEST(LRNLayerTest, TestGradientWithinChannel) {

FILE: src/caffe/test/test_math_functions.cpp
  type caffe (line 16) | namespace caffe {
    class MathFunctionsTest (line 19) | class MathFunctionsTest : public MultiDeviceTest<TypeParam> {
      method MathFunctionsTest (line 23) | MathFunctionsTest()
      method SetUp (line 28) | virtual void SetUp() {
      method ReferenceHammingDistance (line 45) | int ReferenceHammingDistance(const int n, const Dtype* x, const Dtyp...
    class CPUMathFunctionsTest (line 70) | class CPUMathFunctionsTest
    function TYPED_TEST (line 76) | TYPED_TEST(CPUMathFunctionsTest, TestNothing) {
    function TYPED_TEST (line 81) | TYPED_TEST(CPUMathFunctionsTest, TestHammingDistance) {
    function TYPED_TEST (line 89) | TYPED_TEST(CPUMathFunctionsTest, TestAsum) {
    function TYPED_TEST (line 100) | TYPED_TEST(CPUMathFunctionsTest, TestSign) {
    function TYPED_TEST (line 110) | TYPED_TEST(CPUMathFunctionsTest, TestSgnbit) {
    function TYPED_TEST (line 120) | TYPED_TEST(CPUMathFunctionsTest, TestFabs) {
    function TYPED_TEST (line 130) | TYPED_TEST(CPUMathFunctionsTest, TestScale) {
    function TYPED_TEST (line 143) | TYPED_TEST(CPUMathFunctionsTest, TestCopy) {
    class GPUMathFunctionsTest (line 156) | class GPUMathFunctionsTest : public MathFunctionsTest<GPUDevice<Dtype>...
    function TYPED_TEST (line 162) | TYPED_TEST(GPUMathFunctionsTest, DISABLED_TestHammingDistance) {
    function TYPED_TEST (line 173) | TYPED_TEST(GPUMathFunctionsTest, TestAsum) {
    function TYPED_TEST (line 185) | TYPED_TEST(GPUMathFunctionsTest, TestSign) {
    function TYPED_TEST (line 196) | TYPED_TEST(GPUMathFunctionsTest, TestSgnbit) {
    function TYPED_TEST (line 207) | TYPED_TEST(GPUMathFunctionsTest, TestFabs) {
    function TYPED_TEST (line 218) | TYPED_TEST(GPUMathFunctionsTest, TestScale) {
    function TYPED_TEST (line 231) | TYPED_TEST(GPUMathFunctionsTest, TestCopy) {

FILE: src/caffe/test/test_maxpool_dropout_layers.cpp
  type caffe (line 14) | namespace caffe {
    class MaxPoolingDropoutTest (line 17) | class MaxPoolingDropoutTest : public MultiDeviceTest<TypeParam> {
      method MaxPoolingDropoutTest (line 20) | MaxPoolingDropoutTest()
      method SetUp (line 23) | virtual void SetUp() {
    function TYPED_TEST (line 43) | TYPED_TEST(MaxPoolingDropoutTest, TestSetup) {
    function TYPED_TEST (line 60) | TYPED_TEST(MaxPoolingDropoutTest, TestForward) {
    function TYPED_TEST (line 89) | TYPED_TEST(MaxPoolingDropoutTest, TestBackward) {

FILE: src/caffe/test/test_memory_data_layer.cpp
  type caffe (line 11) | namespace caffe {
    class MemoryDataLayerTest (line 14) | class MemoryDataLayerTest : public MultiDeviceTest<TypeParam> {
      method MemoryDataLayerTest (line 18) | MemoryDataLayerTest()
      method SetUp (line 23) | virtual void SetUp() {
    function TYPED_TEST (line 64) | TYPED_TEST(MemoryDataLayerTest, TestSetup) {
    function TYPED_TEST (line 87) | TYPED_TEST(MemoryDataLayerTest, TestForward) {
    function TYPED_TEST (line 116) | TYPED_TEST(MemoryDataLayerTest, AddDatumVectorDefaultTransform) {
    function TYPED_TEST (line 170) | TYPED_TEST(MemoryDataLayerTest, AddMatVectorDefaultTransform) {
    function TYPED_TEST (line 216) | TYPED_TEST(MemoryDataLayerTest, TestSetBatchSize) {

FILE: src/caffe/test/test_multinomial_logistic_loss_layer.cpp
  type caffe (line 16) | namespace caffe {
    class MultinomialLogisticLossLayerTest (line 19) | class MultinomialLogisticLossLayerTest : public CPUDeviceTest<Dtype> {
      method MultinomialLogisticLossLayerTest (line 21) | MultinomialLogisticLossLayerTest()
    function TYPED_TEST (line 52) | TYPED_TEST(MultinomialLogisticLossLayerTest, TestGradientCPU) {

FILE: src/caffe/test/test_mvn_layer.cpp
  type caffe (line 15) | namespace caffe {
    class MVNLayerTest (line 18) | class MVNLayerTest : public MultiDeviceTest<TypeParam> {
      method MVNLayerTest (line 21) | MVNLayerTest()
    function TYPED_TEST (line 40) | TYPED_TEST(MVNLayerTest, TestForward) {
    function TYPED_TEST (line 74) | TYPED_TEST(MVNLayerTest, TestForwardMeanOnly) {
    function TYPED_TEST (line 107) | TYPED_TEST(MVNLayerTest, TestForwardAcrossChannels) {
    function TYPED_TEST (line 143) | TYPED_TEST(MVNLayerTest, TestGradient) {
    function TYPED_TEST (line 152) | TYPED_TEST(MVNLayerTest, TestGradientMeanOnly) {
    function TYPED_TEST (line 163) | TYPED_TEST(MVNLayerTest, TestGradientAcrossChannels) {

FILE: src/caffe/test/test_net.cpp
  type caffe (line 17) | namespace caffe {
    class NetTest (line 20) | class NetTest : public MultiDeviceTest<TypeParam> {
      method NetTest (line 24) | NetTest() : seed_(1701) {}
      method InitNetFromProtoString (line 26) | virtual void InitNetFromProtoString(const string& proto) {
      method CopyNetBlobs (line 32) | virtual void CopyNetBlobs(const bool copy_diff,
      method CopyNetParams (line 45) | virtual void CopyNetParams(const bool copy_diff,
      method InitTinyNet (line 58) | virtual void InitTinyNet(const bool force_backward = false,
      method InitTinyNetEuclidean (line 135) | virtual void InitTinyNetEuclidean(const bool force_backward = false) {
      method InitTrickyNet (line 195) | virtual void InitTrickyNet(Dtype* loss_weight = NULL) {
      method InitUnsharedWeightsNet (line 286) | virtual void InitUnsharedWeightsNet(const Dtype* loss_weight = NULL,
      method InitSharedWeightsNet (line 374) | virtual void InitSharedWeightsNet() {
      method InitDiffDataUnsharedWeightsNet (line 431) | virtual void InitDiffDataUnsharedWeightsNet() {
      method InitDiffDataSharedWeightsNet (line 493) | virtual void InitDiffDataSharedWeightsNet() {
      method InitReshapableNet (line 555) | virtual void InitReshapableNet() {
      method InitSkipPropNet (line 617) | virtual void InitSkipPropNet(bool test_skip_true) {
    function TYPED_TEST (line 722) | TYPED_TEST(NetTest, TestHasBlob) {
    function TYPED_TEST (line 731) | TYPED_TEST(NetTest, TestGetBlob) {
    function TYPED_TEST (line 740) | TYPED_TEST(NetTest, TestHasLayer) {
    function TYPED_TEST (line 748) | TYPED_TEST(NetTest, TestGetLayerByName) {
    function TYPED_TEST (line 756) | TYPED_TEST(NetTest, TestBottomNeedBackward) {
    function TYPED_TEST (line 769) | TYPED_TEST(NetTest, TestBottomNeedBackwardForce) {
    function TYPED_TEST (line 783) | TYPED_TEST(NetTest, TestBottomNeedBackwardEuclideanForce) {
    function TYPED_TEST (line 797) | TYPED_TEST(NetTest, TestBottomNeedBackwardTricky) {
    function TYPED_TEST (line 815) | TYPED_TEST(NetTest, TestLossWeight) {
    function TYPED_TEST (line 866) | TYPED_TEST(NetTest, TestLossWeightMidNet) {
    function TYPED_TEST (line 904) | TYPED_TEST(NetTest, TestComboLossWeight) {
    function TYPED_TEST (line 1034) | TYPED_TEST(NetTest, TestBackwardWithAccuracyLayer) {
    function TYPED_TEST (line 1045) | TYPED_TEST(NetTest, TestUnsharedWeightsDataNet) {
    function TYPED_TEST (line 1054) | TYPED_TEST(NetTest, TestSharedWeightsDataNet) {
    function TYPED_TEST (line 1063) | TYPED_TEST(NetTest, TestUnsharedWeightsDiffNet) {
    function TYPED_TEST (line 1081) | TYPED_TEST(NetTest, TestSharedWeightsDiffNet) {
    function TYPED_TEST (line 1101) | TYPED_TEST(NetTest, TestSharedWeightsUpdate) {
    function TYPED_TEST (line 1183) | TYPED_TEST(NetTest, TestSharedWeightsResume) {
    function TYPED_TEST (line 1229) | TYPED_TEST(NetTest, TestParamPropagateDown) {
    function TYPED_TEST (line 1311) | TYPED_TEST(NetTest, TestFromTo) {
    class FilterNetTest (line 1345) | class FilterNetTest : public ::testing::Test {
      method RunFilterNetTest (line 1347) | void RunFilterNetTest(
    function TEST_F (line 1367) | TEST_F(FilterNetTest, TestNoFilter) {
    function TEST_F (line 1391) | TEST_F(FilterNetTest, TestFilterLeNetTrainTest) {
    function TEST_F (line 1633) | TEST_F(FilterNetTest, TestFilterOutByStage) {
    function TEST_F (line 1672) | TEST_F(FilterNetTest, TestFilterOutByStage2) {
    function TEST_F (line 1711) | TEST_F(FilterNetTest, TestFilterInByStage) {
    function TEST_F (line 1737) | TEST_F(FilterNetTest, TestFilterInByStage2) {
    function TEST_F (line 1762) | TEST_F(FilterNetTest, TestFilterOutByMultipleStage) {
    function TEST_F (line 1805) | TEST_F(FilterNetTest, TestFilterInByMultipleStage) {
    function TEST_F (line 1833) | TEST_F(FilterNetTest, TestFilterInByMultipleStage2) {
    function TEST_F (line 1860) | TEST_F(FilterNetTest, TestFilterInByNotStage) {
    function TEST_F (line 1887) | TEST_F(FilterNetTest, TestFilterOutByNotStage) {
    function TEST_F (line 1923) | TEST_F(FilterNetTest, TestFilterOutByMinLevel) {
    function TEST_F (line 1962) | TEST_F(FilterNetTest, TestFilterOutByMaxLevel) {
    function TEST_F (line 2001) | TEST_F(FilterNetTest, TestFilterInByMinLevel) {
    function TEST_F (line 2026) | TEST_F(FilterNetTest, TestFilterInByMinLevel2) {
    function TEST_F (line 2052) | TEST_F(FilterNetTest, TestFilterInByMaxLevel) {
    function TEST_F (line 2077) | TEST_F(FilterNetTest, TestFilterInByMaxLevel2) {
    function TEST_F (line 2103) | TEST_F(FilterNetTest, TestFilterInOutByIncludeMultiRule) {
    function TEST_F (line 2166) | TEST_F(FilterNetTest, TestFilterInByIncludeMultiRule) {
    function TEST_F (line 2199) | TEST_F(FilterNetTest, TestFilterInOutByExcludeMultiRule) {
    function TYPED_TEST (line 2262) | TYPED_TEST(NetTest, TestReshape) {
    function TYPED_TEST (line 2320) | TYPED_TEST(NetTest, TestSkipPropagateDown) {

FILE: src/caffe/test/test_neuron_layer.cpp
  type caffe (line 16) | namespace caffe {
    class NeuronLayerTest (line 19) | class NeuronLayerTest : public MultiDeviceTest<TypeParam> {
      method NeuronLayerTest (line 23) | NeuronLayerTest()
      method TestDropoutForward (line 40) | void TestDropoutForward(const float dropout_ratio) {
      method TestExpForward (line 72) | void TestExpForward(const float base, const float scale, const float...
      method TestExpGradient (line 94) | void TestExpGradient(const float base, const float scale, const floa...
      method TestPReLU (line 104) | void TestPReLU(PReLULayer<Dtype> *layer) {
      method LogBottomInit (line 121) | void LogBottomInit() {
      method TestLogForward (line 129) | void TestLogForward(const float base, const float scale, const float...
      method TestLogGradient (line 153) | void TestLogGradient(const float base, const float scale, const floa...
    function TYPED_TEST (line 167) | TYPED_TEST(NeuronLayerTest, TestAbsVal) {
    function TYPED_TEST (line 181) | TYPED_TEST(NeuronLayerTest, TestAbsGradient) {
    function TYPED_TEST (line 190) | TYPED_TEST(NeuronLayerTest, TestReLU) {
    function TYPED_TEST (line 205) | TYPED_TEST(NeuronLayerTest, TestReLUGradient) {
    function TYPED_TEST (line 214) | TYPED_TEST(NeuronLayerTest, TestReLUWithNegativeSlope) {
    function TYPED_TEST (line 234) | TYPED_TEST(NeuronLayerTest, TestReLUGradientWithNegativeSlope) {
    function TYPED_TEST (line 245) | TYPED_TEST(NeuronLayerTest, TestSigmoid) {
    function TYPED_TEST (line 262) | TYPED_TEST(NeuronLayerTest, TestSigmoidGradient) {
    function TYPED_TEST (line 271) | TYPED_TEST(NeuronLayerTest, TestTanH) {
    function TYPED_TEST (line 294) | TYPED_TEST(NeuronLayerTest, TestTanHGradient) {
    function TYPED_TEST (line 303) | TYPED_TEST(NeuronLayerTest, TestExpLayer) {
    function TYPED_TEST (line 312) | TYPED_TEST(NeuronLayerTest, TestExpGradient) {
    function TYPED_TEST (line 321) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2) {
    function TYPED_TEST (line 329) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2) {
    function TYPED_TEST (line 337) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Shift1) {
    function TYPED_TEST (line 345) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Shift1) {
    function TYPED_TEST (line 353) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Scale3) {
    function TYPED_TEST (line 361) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Scale3) {
    function TYPED_TEST (line 369) | TYPED_TEST(NeuronLayerTest, TestExpLayerBase2Shift1Scale3) {
    function TYPED_TEST (line 377) | TYPED_TEST(NeuronLayerTest, TestExpGradientBase2Shift1Scale3) {
    function TYPED_TEST (line 385) | TYPED_TEST(NeuronLayerTest, TestLogLayer) {
    function TYPED_TEST (line 394) | TYPED_TEST(NeuronLayerTest, TestLogGradient) {
    function TYPED_TEST (line 403) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2) {
    function TYPED_TEST (line 411) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2) {
    function TYPED_TEST (line 419) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1) {
    function TYPED_TEST (line 427) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1) {
    function TYPED_TEST (line 435) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Scale3) {
    function TYPED_TEST (line 443) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Scale3) {
    function TYPED_TEST (line 451) | TYPED_TEST(NeuronLayerTest, TestLogLayerBase2Shift1Scale3) {
    function TYPED_TEST (line 459) | TYPED_TEST(NeuronLayerTest, TestLogGradientBase2Shift1Scale3) {
    function TYPED_TEST (line 467) | TYPED_TEST(NeuronLayerTest, TestDropoutHalf) {
    function TYPED_TEST (line 472) | TYPED_TEST(NeuronLayerTest, TestDropoutThreeQuarters) {
    function TYPED_TEST (line 477) | TYPED_TEST(NeuronLayerTest, TestDropoutTestPhase) {
    function TYPED_TEST (line 494) | TYPED_TEST(NeuronLayerTest, TestDropoutGradient) {
    function TYPED_TEST (line 504) | TYPED_TEST(NeuronLayerTest, TestDropoutGradientTest) {
    function TYPED_TEST (line 514) | TYPED_TEST(NeuronLayerTest, TestBNLL) {
    function TYPED_TEST (line 529) | TYPED_TEST(NeuronLayerTest, TestBNLLGradient) {
    function TYPED_TEST (line 538) | TYPED_TEST(NeuronLayerTest, TestPReLUParam) {
    function TYPED_TEST (line 550) | TYPED_TEST(NeuronLayerTest, TestPReLUForward) {
    function TYPED_TEST (line 561) | TYPED_TEST(NeuronLayerTest, TestPReLUForwardChannelShared) {
    function TYPED_TEST (line 570) | TYPED_TEST(NeuronLayerTest, TestPReLUGradient) {
    function TYPED_TEST (line 583) | TYPED_TEST(NeuronLayerTest, TestPReLUGradientChannelShared) {
    function TYPED_TEST (line 594) | TYPED_TEST(NeuronLayerTest, TestPReLUConsistencyReLU) {
    function TYPED_TEST (line 637) | TYPED_TEST(NeuronLayerTest, TestPReLUInPlace) {
    class CuDNNNeuronLayerTest (line 714) | class CuDNNNeuronLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNNeuronLayerTest (line 716) | CuDNNNeuronLayerTest()
    function TYPED_TEST (line 736) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUCuDNN) {
    function TYPED_TEST (line 750) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUGradientCuDNN) {
    function TYPED_TEST (line 758) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUWithNegativeSlopeCuDNN) {
    function TYPED_TEST (line 777) | TYPED_TEST(CuDNNNeuronLayerTest, TestReLUGradientWithNegativeSlopeCuDN...
    function TYPED_TEST (line 787) | TYPED_TEST(CuDNNNeuronLayerTest, TestSigmoidCuDNN) {
    function TYPED_TEST (line 803) | TYPED_TEST(CuDNNNeuronLayerTest, TestSigmoidGradientCuDNN) {
    function TYPED_TEST (line 811) | TYPED_TEST(CuDNNNeuronLayerTest, TestTanHCuDNN) {
    function TYPED_TEST (line 833) | TYPED_TEST(CuDNNNeuronLayerTest, TestTanHGradientCuDNN) {

FILE: src/caffe/test/test_platform.cpp
  type caffe (line 11) | namespace caffe {
    class PlatformTest (line 15) | class PlatformTest : public ::testing::Test {}
    function TEST_F (line 17) | TEST_F(PlatformTest, TestInitialization) {

FILE: src/caffe/test/test_pooling_layer.cpp
  type caffe (line 14) | namespace caffe {
    class PoolingLayerTest (line 17) | class PoolingLayerTest : public MultiDeviceTest<TypeParam> {
      method PoolingLayerTest (line 21) | PoolingLayerTest()
      method SetUp (line 25) | virtual void SetUp() {
      method TestForwardSquare (line 46) | void TestForwardSquare() {
      method TestForwardRectHigh (line 118) | void TestForwardRectHigh() {
      method TestForwardRectWide (line 243) | void TestForwardRectWide() {
    function TYPED_TEST (line 373) | TYPED_TEST(PoolingLayerTest, TestSetup) {
    function TYPED_TEST (line 387) | TYPED_TEST(PoolingLayerTest, TestSetupPadded) {
    function TYPED_TEST (line 403) | TYPED_TEST(PoolingLayerTest, TestSetupGlobalPooling) {
    function TYPED_TEST (line 443) | TYPED_TEST(PoolingLayerTest, TestForwardMax) {
    function TYPED_TEST (line 449) | TYPED_TEST(PoolingLayerTest, TestForwardMaxTopMask) {
    function TYPED_TEST (line 456) | TYPED_TEST(PoolingLayerTest, TestGradientMax) {
    function TYPED_TEST (line 475) | TYPED_TEST(PoolingLayerTest, TestForwardMaxPadded) {
    function TYPED_TEST (line 520) | TYPED_TEST(PoolingLayerTest, TestGradientMaxTopMask) {
    function TYPED_TEST (line 540) | TYPED_TEST(PoolingLayerTest, TestForwardAve) {
    function TYPED_TEST (line 572) | TYPED_TEST(PoolingLayerTest, TestGradientAve) {
    function TYPED_TEST (line 590) | TYPED_TEST(PoolingLayerTest, TestGradientAvePadded) {
    class CuDNNPoolingLayerTest (line 611) | class CuDNNPoolingLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNPoolingLayerTest (line 613) | CuDNNPoolingLayerTest()
      method SetUp (line 617) | virtual void SetUp() {
      method TestForwardSquare (line 638) | void TestForwardSquare() {
      method TestForwardRectHigh (line 710) | void TestForwardRectHigh() {
      method TestForwardRectWide (line 835) | void TestForwardRectWide() {
    function TYPED_TEST (line 965) | TYPED_TEST(CuDNNPoolingLayerTest, TestSetupCuDNN) {
    function TYPED_TEST (line 978) | TYPED_TEST(CuDNNPoolingLayerTest, TestSetupPaddedCuDNN) {
    function TYPED_TEST (line 1019) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardMaxCuDNN) {
    function TYPED_TEST (line 1036) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientMaxCuDNN) {
    function TYPED_TEST (line 1055) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardMaxPaddedCuDNN) {
    function TYPED_TEST (line 1120) | TYPED_TEST(CuDNNPoolingLayerTest, TestForwardAveCuDNN) {
    function TYPED_TEST (line 1145) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientAveCuDNN) {
    function TYPED_TEST (line 1162) | TYPED_TEST(CuDNNPoolingLayerTest, TestGradientAvePaddedCuDNN) {

FILE: src/caffe/test/test_power_layer.cpp
  type caffe (line 14) | namespace caffe {
    class PowerLayerTest (line 17) | class PowerLayerTest : public MultiDeviceTest<TypeParam> {
      method PowerLayerTest (line 21) | PowerLayerTest()
      method TestForward (line 34) | void TestForward(Dtype power, Dtype scale, Dtype shift) {
      method TestBackward (line 61) | void TestBackward(Dtype power, Dtype scale, Dtype shift) {
    function TYPED_TEST (line 90) | TYPED_TEST(PowerLayerTest, TestPower) {
    function TYPED_TEST (line 98) | TYPED_TEST(PowerLayerTest, TestPowerGradient) {
    function TYPED_TEST (line 106) | TYPED_TEST(PowerLayerTest, TestPowerGradientShiftZero) {
    function TYPED_TEST (line 114) | TYPED_TEST(PowerLayerTest, TestPowerZero) {
    function TYPED_TEST (line 122) | TYPED_TEST(PowerLayerTest, TestPowerZeroGradient) {
    function TYPED_TEST (line 130) | TYPED_TEST(PowerLayerTest, TestPowerOne) {
    function TYPED_TEST (line 138) | TYPED_TEST(PowerLayerTest, TestPowerOneGradient) {
    function TYPED_TEST (line 146) | TYPED_TEST(PowerLayerTest, TestPowerTwo) {
    function TYPED_TEST (line 154) | TYPED_TEST(PowerLayerTest, TestPowerTwoGradient) {
    function TYPED_TEST (line 162) | TYPED_TEST(PowerLayerTest, TestPowerTwoScaleHalfGradient) {

FILE: src/caffe/test/test_protobuf.cpp
  type caffe (line 12) | namespace caffe {
    class ProtoTest (line 14) | class ProtoTest : public ::testing::Test {}
    function TEST_F (line 16) | TEST_F(ProtoTest, TestSerialization) {

FILE: src/caffe/test/test_random_number_generator.cpp
  type caffe (line 12) | namespace caffe {
    class RandomNumberGeneratorTest (line 15) | class RandomNumberGeneratorTest : public ::testing::Test {
      method RandomNumberGeneratorTest (line 17) | RandomNumberGeneratorTest()
      method SetUp (line 26) | virtual void SetUp() {
      method Dtype (line 30) | Dtype sample_mean(const Dtype* const seqs, const int sample_size) {
      method Dtype (line 38) | Dtype sample_mean(const Dtype* const seqs) {
      method Dtype (line 42) | Dtype sample_mean(const int* const seqs, const int sample_size) {
      method Dtype (line 50) | Dtype sample_mean(const int* const seqs) {
      method Dtype (line 54) | Dtype mean_bound(const Dtype std, const int sample_size) {
      method Dtype (line 58) | Dtype mean_bound(const Dtype std) {
      method RngGaussianFill (line 62) | void RngGaussianFill(const Dtype mu, const Dtype sigma, void* cpu_da...
      method RngGaussianChecks (line 67) | void RngGaussianChecks(const Dtype mu, const Dtype sigma,
      method RngUniformFill (line 105) | void RngUniformFill(const Dtype lower, const Dtype upper, void* cpu_...
      method RngUniformChecks (line 111) | void RngUniformChecks(const Dtype lower, const Dtype upper,
      method RngBernoulliFill (line 158) | void RngBernoulliFill(const Dtype p, void* cpu_data) {
      method RngBernoulliChecks (line 163) | void RngBernoulliChecks(const Dtype p, const void* cpu_data) {
      method RngGaussianFillGPU (line 174) | void RngGaussianFillGPU(const Dtype mu, const Dtype sigma, void* gpu...
      method RngUniformFillGPU (line 179) | void RngUniformFillGPU(const Dtype lower, const Dtype upper, void* g...
      method RngUniformIntFillGPU (line 187) | void RngUniformIntFillGPU(void* gpu_data) {
    function TYPED_TEST (line 210) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussian) {
    function TYPED_TEST (line 219) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussian2) {
    function TYPED_TEST (line 228) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniform) {
    function TYPED_TEST (line 237) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniform2) {
    function TYPED_TEST (line 246) | TYPED_TEST(RandomNumberGeneratorTest, TestRngBernoulli) {
    function TYPED_TEST (line 254) | TYPED_TEST(RandomNumberGeneratorTest, TestRngBernoulli2) {
    function TYPED_TEST (line 262) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussianTimesGaussian) {
    function TYPED_TEST (line 288) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniformTimesUniform) {
    function TYPED_TEST (line 316) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussianTimesBernoulli) {
    function TYPED_TEST (line 341) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniformTimesBernoulli) {
    function TYPED_TEST (line 366) | TYPED_TEST(RandomNumberGeneratorTest, TestRngBernoulliTimesBernoulli) {
    function TYPED_TEST (line 401) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussianGPU) {
    function TYPED_TEST (line 411) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussian2GPU) {
    function TYPED_TEST (line 421) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniformGPU) {
    function TYPED_TEST (line 431) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniform2GPU) {
    function TYPED_TEST (line 441) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniformIntGPU) {
    function TYPED_TEST (line 458) | TYPED_TEST(RandomNumberGeneratorTest, TestRngGaussianTimesGaussianGPU) {
    function TYPED_TEST (line 489) | TYPED_TEST(RandomNumberGeneratorTest, TestRngUniformTimesUniformGPU) {

FILE: src/caffe/test/test_reduction_layer.cpp
  type caffe (line 14) | namespace caffe {
    class ReductionLayerTest (line 17) | class ReductionLayerTest : public MultiDeviceTest<TypeParam> {
      method ReductionLayerTest (line 21) | ReductionLayerTest()
      method TestForward (line 37) | void TestForward(ReductionParameter_ReductionOp op,
      method TestGradient (line 81) | void TestGradient(ReductionParameter_ReductionOp op,
    function TYPED_TEST (line 103) | TYPED_TEST(ReductionLayerTest, TestSetUp) {
    function TYPED_TEST (line 112) | TYPED_TEST(ReductionLayerTest, TestSetUpWithAxis1) {
    function TYPED_TEST (line 123) | TYPED_TEST(ReductionLayerTest, TestSetUpWithAxis2) {
    function TYPED_TEST (line 135) | TYPED_TEST(ReductionLayerTest, TestSum) {
    function TYPED_TEST (line 140) | TYPED_TEST(ReductionLayerTest, TestSumCoeff) {
    function TYPED_TEST (line 146) | TYPED_TEST(ReductionLayerTest, TestSumCoeffAxis1) {
    function TYPED_TEST (line 153) | TYPED_TEST(ReductionLayerTest, TestSumGradient) {
    function TYPED_TEST (line 158) | TYPED_TEST(ReductionLayerTest, TestSumCoeffGradient) {
    function TYPED_TEST (line 164) | TYPED_TEST(ReductionLayerTest, TestSumCoeffAxis1Gradient) {
    function TYPED_TEST (line 171) | TYPED_TEST(ReductionLayerTest, TestMean) {
    function TYPED_TEST (line 177) | TYPED_TEST(ReductionLayerTest, TestMeanCoeff) {
    function TYPED_TEST (line 184) | TYPED_TEST(ReductionLayerTest, TestMeanCoeffAxis1) {
    function TYPED_TEST (line 192) | TYPED_TEST(ReductionLayerTest, TestMeanGradient) {
    function TYPED_TEST (line 198) | TYPED_TEST(ReductionLayerTest, TestMeanCoeffGradient) {
    function TYPED_TEST (line 205) | TYPED_TEST(ReductionLayerTest, TestMeanCoeffGradientAxis1) {
    function TYPED_TEST (line 213) | TYPED_TEST(ReductionLayerTest, TestAbsSum) {
    function TYPED_TEST (line 219) | TYPED_TEST(ReductionLayerTest, TestAbsSumCoeff) {
    function TYPED_TEST (line 226) | TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffAxis1) {
    function TYPED_TEST (line 234) | TYPED_TEST(ReductionLayerTest, TestAbsSumGradient) {
    function TYPED_TEST (line 240) | TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffGradient) {
    function TYPED_TEST (line 247) | TYPED_TEST(ReductionLayerTest, TestAbsSumCoeffAxis1Gradient) {
    function TYPED_TEST (line 255) | TYPED_TEST(ReductionLayerTest, TestSumOfSquares) {
    function TYPED_TEST (line 261) | TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeff) {
    function TYPED_TEST (line 268) | TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffAxis1) {
    function TYPED_TEST (line 276) | TYPED_TEST(ReductionLayerTest, TestSumOfSquaresGradient) {
    function TYPED_TEST (line 282) | TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffGradient) {
    function TYPED_TEST (line 289) | TYPED_TEST(ReductionLayerTest, TestSumOfSquaresCoeffAxis1Gradient) {

FILE: src/caffe/test/test_reshape_layer.cpp
  type caffe (line 14) | namespace caffe {
    class ReshapeLayerTest (line 17) | class ReshapeLayerTest : public MultiDeviceTest<TypeParam> {
      method ReshapeLayerTest (line 20) | ReshapeLayerTest()
    function TYPED_TEST (line 41) | TYPED_TEST(ReshapeLayerTest, TestFlattenOutputSizes) {
    function TYPED_TEST (line 58) | TYPED_TEST(ReshapeLayerTest, TestFlattenValues) {
    function TYPED_TEST (line 79) | TYPED_TEST(ReshapeLayerTest, TestCopyDimensions) {
    function TYPED_TEST (line 98) | TYPED_TEST(ReshapeLayerTest, TestInferenceOfUnspecified) {
    function TYPED_TEST (line 118) | TYPED_TEST(ReshapeLayerTest, TestInferenceOfUnspecifiedWithStartAxis) {
    function TYPED_TEST (line 137) | TYPED_TEST(ReshapeLayerTest, TestInsertSingletonAxesStart) {
    function TYPED_TEST (line 160) | TYPED_TEST(ReshapeLayerTest, TestInsertSingletonAxesMiddle) {
    function TYPED_TEST (line 183) | TYPED_TEST(ReshapeLayerTest, TestInsertSingletonAxesEnd) {
    function TYPED_TEST (line 206) | TYPED_TEST(ReshapeLayerTest, TestFlattenMiddle) {
    function TYPED_TEST (line 223) | TYPED_TEST(ReshapeLayerTest, TestForward) {
    function TYPED_TEST (line 240) | TYPED_TEST(ReshapeLayerTest, TestForwardAfterReshape) {
    function TYPED_TEST (line 266) | TYPED_TEST(ReshapeLayerTest, TestGradient) {

FILE: src/caffe/test/test_sigmoid_cross_entropy_loss_layer.cpp
  type caffe (line 16) | namespace caffe {
    class SigmoidCrossEntropyLossLayerTest (line 19) | class SigmoidCrossEntropyLossLayerTest : public MultiDeviceTest<TypePa...
      method SigmoidCrossEntropyLossLayerTest (line 23) | SigmoidCrossEntropyLossLayerTest()
      method Dtype (line 48) | Dtype SigmoidCrossEntropyLossReference(const int count, const int num,
      method TestForward (line 64) | void TestForward() {
    function TYPED_TEST (line 105) | TYPED_TEST(SigmoidCrossEntropyLossLayerTest, TestSigmoidCrossEntropyLo...
    function TYPED_TEST (line 109) | TYPED_TEST(SigmoidCrossEntropyLossLayerTest, TestGradient) {

FILE: src/caffe/test/test_slice_layer.cpp
  type caffe (line 14) | namespace caffe {
    class SliceLayerTest (line 17) | class SliceLayerTest : public MultiDeviceTest<TypeParam> {
      method SliceLayerTest (line 21) | SliceLayerTest()
      method SetUp (line 26) | virtual void SetUp() {
      method ReduceBottomBlobSize (line 40) | virtual void ReduceBottomBlobSize() {
    function TYPED_TEST (line 62) | TYPED_TEST(SliceLayerTest, TestSetupNum) {
    function TYPED_TEST (line 76) | TYPED_TEST(SliceLayerTest, TestSetupChannels) {
    function TYPED_TEST (line 91) | TYPED_TEST(SliceLayerTest, TestTrivialSlice) {
    function TYPED_TEST (line 106) | TYPED_TEST(SliceLayerTest, TestSliceAcrossNum) {
    function TYPED_TEST (line 136) | TYPED_TEST(SliceLayerTest, TestSliceAcrossChannels) {
    function TYPED_TEST (line 179) | TYPED_TEST(SliceLayerTest, TestGradientTrivial) {
    function TYPED_TEST (line 191) | TYPED_TEST(SliceLayerTest, TestGradientAcrossNum) {
    function TYPED_TEST (line 203) | TYPED_TEST(SliceLayerTest, TestGradientAcrossChannels) {

FILE: src/caffe/test/test_softmax_layer.cpp
  type caffe (line 15) | namespace caffe {
    class SoftmaxLayerTest (line 18) | class SoftmaxLayerTest : public MultiDeviceTest<TypeParam> {
      method SoftmaxLayerTest (line 21) | SoftmaxLayerTest()
    function TYPED_TEST (line 40) | TYPED_TEST(SoftmaxLayerTest, TestForward) {
    function TYPED_TEST (line 74) | TYPED_TEST(SoftmaxLayerTest, TestGradient) {
    class CuDNNSoftmaxLayerTest (line 85) | class CuDNNSoftmaxLayerTest : public GPUDeviceTest<Dtype> {
      method CuDNNSoftmaxLayerTest (line 87) | CuDNNSoftmaxLayerTest()
    function TYPED_TEST (line 106) | TYPED_TEST(CuDNNSoftmaxLayerTest, TestForwardCuDNN) {
    function TYPED_TEST (line 139) | TYPED_TEST(CuDNNSoftmaxLayerTest, TestGradientCuDNN) {

FILE: src/caffe/test/test_softmax_with_loss_layer.cpp
  type caffe (line 19) | namespace caffe {
    class SoftmaxWithLossLayerTest (line 22) | class SoftmaxWithLossLayerTest : public MultiDeviceTest<TypeParam> {
      method SoftmaxWithLossLayerTest (line 26) | SoftmaxWithLossLayerTest()
    function TYPED_TEST (line 56) | TYPED_TEST(SoftmaxWithLossLayerTest, TestGradient) {
    function TYPED_TEST (line 66) | TYPED_TEST(SoftmaxWithLossLayerTest, TestForwardIgnoreLabel) {
    function TYPED_TEST (line 89) | TYPED_TEST(SoftmaxWithLossLayerTest, TestGradientIgnoreLabel) {
    function TYPED_TEST (line 100) | TYPED_TEST(SoftmaxWithLossLayerTest, TestGradientUnnormalized) {

FILE: src/caffe/test/test_solver.cpp
  type caffe (line 16) | namespace caffe {
    class SolverTest (line 19) | class SolverTest : public MultiDeviceTest<TypeParam> {
      method InitSolverFromProtoString (line 23) | virtual void InitSolverFromProtoString(const string& proto) {
    function TYPED_TEST (line 45) | TYPED_TEST(SolverTest, TestInitTrainTestNets) {

FILE: src/caffe/test/test_split_layer.cpp
  type caffe (line 18) | namespace caffe {
    class SplitLayerTest (line 21) | class SplitLayerTest : public MultiDeviceTest<TypeParam> {
      method SplitLayerTest (line 25) | SplitLayerTest()
    function TYPED_TEST (line 51) | TYPED_TEST(SplitLayerTest, TestSetup) {
    function TYPED_TEST (line 66) | TYPED_TEST(SplitLayerTest, Test) {
    function TYPED_TEST (line 79) | TYPED_TEST(SplitLayerTest, TestGradient) {
    class SplitLayerInsertionTest (line 89) | class SplitLayerInsertionTest : public ::testing::Test {
      method RunInsertionTest (line 91) | void RunInsertionTest(
    function TEST_F (line 114) | TEST_F(SplitLayerInsertionTest, TestNoInsertion1) {
    function TEST_F (line 138) | TEST_F(SplitLayerInsertionTest, TestNoInsertion2) {
    function TEST_F (line 175) | TEST_F(SplitLayerInsertionTest, TestNoInsertionImageNet) {
    function TEST_F (line 530) | TEST_F(SplitLayerInsertionTest, TestNoInsertionWithInPlace) {
    function TEST_F (line 560) | TEST_F(SplitLayerInsertionTest, TestLossInsertion) {
    function TEST_F (line 689) | TEST_F(SplitLayerInsertionTest, TestInsertion) {
    function TEST_F (line 784) | TEST_F(SplitLayerInsertionTest, TestInsertionTwoTop) {
    function TEST_F (line 890) | TEST_F(SplitLayerInsertionTest, TestInputInsertion) {
    function TEST_F (line 951) | TEST_F(SplitLayerInsertionTest, TestWithInPlace) {

FILE: src/caffe/test/test_spp_layer.cpp
  type caffe (line 15) | namespace caffe {
    class SPPLayerTest (line 18) | class SPPLayerTest : public MultiDeviceTest<TypeParam> {
      method SPPLayerTest (line 22) | SPPLayerTest()
      method SetUp (line 27) | virtual void SetUp() {
    function TYPED_TEST (line 55) | TYPED_TEST(SPPLayerTest, TestSetup) {
    function TYPED_TEST (line 72) | TYPED_TEST(SPPLayerTest, TestEqualOutputDims) {
    function TYPED_TEST (line 89) | TYPED_TEST(SPPLayerTest, TestEqualOutputDims2) {
    function TYPED_TEST (line 106) | TYPED_TEST(SPPLayerTest, TestForwardBackward) {
    function TYPED_TEST (line 118) | TYPED_TEST(SPPLayerTest, TestGradient) {

FILE: src/caffe/test/test_stochastic_pooling.cpp
  type caffe (line 17) | namespace caffe {
    class StochasticPoolingLayerTest (line 20) | class StochasticPoolingLayerTest : public MultiDeviceTest<TypeParam> {
      method StochasticPoolingLayerTest (line 24) | StochasticPoolingLayerTest()
      method SetUp (line 27) | virtual void SetUp() {
    class CPUStochasticPoolingLayerTest (line 51) | class CPUStochasticPoolingLayerTest
    function TYPED_TEST (line 57) | TYPED_TEST(CPUStochasticPoolingLayerTest, TestSetup) {
    class GPUStochasticPoolingLayerTest (line 73) | class GPUStochasticPoolingLayerTest
    function TYPED_TEST (line 79) | TYPED_TEST(GPUStochasticPoolingLayerTest, TestStochastic) {
    function TYPED_TEST (line 122) | TYPED_TEST(GPUStochasticPoolingLayerTest, TestStochasticTestPhase) {
    function TYPED_TEST (line 159) | TYPED_TEST(GPUStochasticPoolingLayerTest, TestGradient) {

FILE: src/caffe/test/test_syncedmem.cpp
  type caffe (line 13) | namespace caffe {
    class SyncedMemoryTest (line 15) | class SyncedMemoryTest : public ::testing::Test {}
    function TEST_F (line 17) | TEST_F(SyncedMemoryTest, TestInitialization) {
    function TEST_F (line 28) | TEST_F(SyncedMemoryTest, TestAllocationCPUGPU) {
    function TEST_F (line 38) | TEST_F(SyncedMemoryTest, TestAllocationCPU) {
    function TEST_F (line 46) | TEST_F(SyncedMemoryTest, TestAllocationGPU) {
    function TEST_F (line 54) | TEST_F(SyncedMemoryTest, TestCPUWrite) {
    function TEST_F (line 73) | TEST_F(SyncedMemoryTest, TestGPURead) {
    function TEST_F (line 103) | TEST_F(SyncedMemoryTest, TestGPUWrite) {

FILE: src/caffe/test/test_tanh_layer.cpp
  type caffe (line 14) | namespace caffe {
    function tanh_naive (line 16) | double tanh_naive(double x) {
    class TanHLayerTest (line 31) | class TanHLayerTest : public MultiDeviceTest<TypeParam> {
      method TanHLayerTest (line 35) | TanHLayerTest()
      method TestForward (line 45) | void TestForward(Dtype filler_std) {
      method TestBackward (line 67) | void TestBackward(Dtype filler_std) {
    function TYPED_TEST (line 88) | TYPED_TEST(TanHLayerTest, TestTanH) {
    function TYPED_TEST (line 92) | TYPED_TEST(TanHLayerTest, TestTanHOverflow) {
    function TYPED_TEST (line 97) | TYPED_TEST(TanHLayerTest, TestTanHGradient) {

FILE: src/caffe/test/test_threshold_layer.cpp
  type caffe (line 12) | namespace caffe {
    class ThresholdLayerTest (line 15) | class ThresholdLayerTest : public MultiDeviceTest<TypeParam> {
      method ThresholdLayerTest (line 18) | ThresholdLayerTest()
    function TYPED_TEST (line 39) | TYPED_TEST(ThresholdLayerTest, TestSetup) {
    function TYPED_TEST (line 50) | TYPED_TEST(ThresholdLayerTest, Test) {
    function TYPED_TEST (line 72) | TYPED_TEST(ThresholdLayerTest, Test2) {

FILE: src/caffe/test/test_tile_layer.cpp
  type caffe (line 14) | namespace caffe {
    class TileLayerTest (line 17) | class TileLayerTest : public MultiDeviceTest<TypeParam> {
      method TileLayerTest (line 21) | TileLayerTest()
      method SetUp (line 24) | virtual void SetUp() {
    function TYPED_TEST (line 47) | TYPED_TEST(TileLayerTest, TestTrivialSetup) {
    function TYPED_TEST (line 63) | TYPED_TEST(TileLayerTest, TestSetup) {
    function TYPED_TEST (line 81) | TYPED_TEST(TileLayerTest, TestForwardNum) {
    function TYPED_TEST (line 104) | TYPED_TEST(TileLayerTest, TestForwardChannels) {
    function TYPED_TEST (line 125) | TYPED_TEST(TileLayerTest, TestTrivialGradient) {
    function TYPED_TEST (line 136) | TYPED_TEST(TileLayerTest, TestGradientNum) {
    function TYPED_TEST (line 149) | TYPED_TEST(TileLayerTest, TestGradientChannels) {

FILE: src/caffe/test/test_upgrade_proto.cpp
  type caffe (line 18) | namespace caffe {
    class PaddingLayerUpgradeTest (line 20) | class PaddingLayerUpgradeTest : public ::testing::Test {
      method RunPaddingUpgradeTest (line 22) | void RunPaddingUpgradeTest(
    function TEST_F (line 45) | TEST_F(PaddingLayerUpgradeTest, TestSimple) {
    function TEST_F (line 193) | TEST_F(PaddingLayerUpgradeTest, TestTwoTops) {
    function TEST_F (line 388) | TEST_F(PaddingLayerUpgradeTest, TestImageNet) {
    class NetUpgradeTest (line 1090) | class NetUpgradeTest : public ::testing::Test {
      method RunV0UpgradeTest (line 1092) | void RunV0UpgradeTest(
      method RunV1UpgradeTest (line 1109) | void RunV1UpgradeTest(
    function TEST_F (line 1127) | TEST_F(NetUpgradeTest, TestSimple) {
    function TEST_F (line 1354) | TEST_F(NetUpgradeTest, TestAllParams) {
    function TEST_F (line 1854) | TEST_F(NetUpgradeTest, TestImageNet) {
    function TEST_F (line 2895) | TEST_F(NetUpgradeTest, TestUpgradeV1LayerType) {

FILE: src/caffe/test/test_util_blas.cpp
  type caffe (line 13) | namespace caffe {
    class GemmTest (line 18) | class GemmTest : public ::testing::Test {}
    function TYPED_TEST (line 22) | TYPED_TEST(GemmTest, TestGemmCPUGPU) {
    function TYPED_TEST (line 93) | TYPED_TEST(GemmTest, TestGemvCPUGPU) {

FILE: src/caffe/util/benchmark.cpp
  type caffe (line 6) | namespace caffe {

FILE: src/caffe/util/blocking_queue.cpp
  type caffe (line 9) | namespace caffe {
    class BlockingQueue<T>::sync (line 12) | class BlockingQueue<T>::sync {
    function T (line 45) | T BlockingQueue<T>::pop(const string& log_on_wait) {
    function T (line 73) | T BlockingQueue<T>::peek() {
    class BlockingQueue<Batch<float>*> (line 89) | class BlockingQueue<Batch<float>*>
    class BlockingQueue<Batch<double>*> (line 90) | class BlockingQueue<Batch<double>*>
    class BlockingQueue<Datum*> (line 91) | class BlockingQueue<Datum*>
    class BlockingQueue<shared_ptr<DataReader::QueuePair> > (line 92) | class BlockingQueue<shared_ptr<DataReader::QueuePair> >
    class BlockingQueue<P2PSync<float>*> (line 93) | class BlockingQueue<P2PSync<float>*>
    class BlockingQueue<P2PSync<double>*> (line 94) | class BlockingQueue<P2PSync<double>*>

FILE: src/caffe/util/cudnn.cpp
  type caffe (line 4) | namespace caffe {
    type cudnn (line 5) | namespace cudnn {

FILE: src/caffe/util/db.cpp
  type caffe (line 7) | namespace caffe { namespace db {
    type db (line 7) | namespace db {
      function DB (line 9) | DB* GetDB(DataParameter::DB backend) {
      function DB (line 20) | DB* GetDB(const string& backend) {

FILE: src/caffe/util/db_leveldb.cpp
  type caffe (line 5) | namespace caffe { namespace db {
    type db (line 5) | namespace db {

FILE: src/caffe/util/db_lmdb.cpp
  type caffe (line 7) | namespace caffe { namespace db {
    type db (line 7) | namespace db {
      function LMDBCursor (line 25) | LMDBCursor* LMDB::NewCursor() {
      function LMDBTransaction (line 34) | LMDBTransaction* LMDB::NewTransaction() {

FILE: src/caffe/util/hdf5.cpp
  type caffe (line 6) | namespace caffe {
    function hdf5_load_nd_dataset_helper (line 10) | void hdf5_load_nd_dataset_helper(
    function string (line 99) | string hdf5_load_string(hid_t loc_id, const string& dataset_name) {
    function hdf5_save_string (line 115) | void hdf5_save_string(hid_t loc_id, const string& dataset_name,
    function hdf5_load_int (line 123) | int hdf5_load_int(hid_t loc_id, const string& dataset_name) {
    function hdf5_save_int (line 131) | void hdf5_save_int(hid_t loc_id, const string& dataset_name, int i) {
    function hdf5_get_num_links (line 139) | int hdf5_get_num_links(hid_t loc_id) {
    function string (line 146) | string hdf5_get_name_by_idx(hid_t loc_id, int idx) {

FILE: src/caffe/util/im2col.cpp
  type caffe (line 8) | namespace caffe {
    function im2col_cpu (line 11) | void im2col_cpu(const Dtype* data_im, const int channels,
    function col2im_cpu (line 48) | void col2im_cpu(const Dtype* data_col, const int channels,

FILE: src/caffe/util/insert_splits.cpp
  type caffe (line 10) | namespace caffe {
    function InsertSplits (line 12) | void InsertSplits(const NetParameter& param, NetParameter* param_split) {
    function ConfigureSplitLayer (line 109) | void ConfigureSplitLayer(const string& layer_name, const string& blob_...
    function string (line 129) | string SplitLayerName(const string& layer_name, const string& blob_name,
    function string (line 137) | string SplitBlobName(const string& layer_name, const string& blob_name,

FILE: src/caffe/util/io.cpp
  type caffe (line 22) | namespace caffe {
    function ReadProtoFromTextFile (line 32) | bool ReadProtoFromTextFile(const char* filename, Message* proto) {
    function WriteProtoToTextFile (line 42) | void WriteProtoToTextFile(const Message& proto, const char* filename) {
    function ReadProtoFromBinaryFile (line 50) | bool ReadProtoFromBinaryFile(const char* filename, Message* proto) {
    function WriteProtoToBinaryFile (line 65) | void WriteProtoToBinaryFile(const Message& proto, const char* filename) {
    function ReadImageToCVMat (line 70) | cv::Mat ReadImageToCVMat(const string& filename,
    function ReadImageToCVMat (line 88) | cv::Mat ReadImageToCVMat(const string& filename,
    function ReadImageToCVMat (line 93) | cv::Mat ReadImageToCVMat(const string& filename,
    function ReadImageToCVMat (line 98) | cv::Mat ReadImageToCVMat(const string& filename) {
    function matchExt (line 102) | static bool matchExt(const std::string & fn,
    function ReadImageToDatum (line 114) | bool ReadImageToDatum(const string& filename, const int label,
    function ReadFileToDatum (line 139) | bool ReadFileToDatum(const string& filename, const int label,
    function DecodeDatumToCVMatNative (line 159) | cv::Mat DecodeDatumToCVMatNative(const Datum& datum) {
    function DecodeDatumToCVMat (line 170) | cv::Mat DecodeDatumToCVMat(const Datum& datum, bool is_color) {
    function DecodeDatumNative (line 186) | bool DecodeDatumNative(Datum* datum) {
    function DecodeDatum (line 195) | bool DecodeDatum(Datum* datum, bool is_color) {
    function CVMatToDatum (line 205) | void CVMatToDatum(const cv::Mat& cv_img, Datum* datum) {

FILE: src/caffe/util/math_functions.cpp
  type caffe (line 10) | namespace caffe {
    function caffe_set (line 57) | void caffe_set(const int N, const Dtype alpha, Dtype* Y) {
    function caffe_add_scalar (line 72) | void caffe_add_scalar(const int N, const float alpha, float* Y) {
    function caffe_add_scalar (line 79) | void caffe_add_scalar(const int N, const double alpha, double* Y) {
    function caffe_copy (line 86) | void caffe_copy(const int N, const Dtype* X, Dtype* Y) {
    function caffe_rng_rand (line 229) | unsigned int caffe_rng_rand() {
    function Dtype (line 234) | Dtype caffe_nextafter(const Dtype b) {
    function caffe_rng_uniform (line 246) | void caffe_rng_uniform(const int n, const Dtype a, const Dtype b, Dtyp...
    function caffe_rng_gaussian (line 267) | void caffe_rng_gaussian(const int n, const Dtype a,
    function caffe_rng_bernoulli (line 289) | void caffe_rng_bernoulli(const int n, const Dtype p, int* r) {
    function caffe_rng_bernoulli (line 309) | void caffe_rng_bernoulli(const int n, const Dtype p, unsigned int* r) {
    function Dtype (line 341) | Dtype caffe_cpu_dot(const int n, const Dtype* x, const Dtype* y) {

FILE: src/caffe/util/signal_handler.cpp
  function handle_signal (line 14) | void handle_signal(int signal) {
  function HookupHandler (line 25) | void HookupHandler() {
  function UnhookHandler (line 48) | void UnhookHandler() {
  function GotSIGINT (line 71) | bool GotSIGINT() {
  function GotSIGHUP (line 79) | bool GotSIGHUP() {
  type caffe (line 86) | namespace caffe {
    function ActionCallback (line 111) | ActionCallback SignalHandler::GetActionFunction() {

FILE: src/caffe/util/upgrade_proto.cpp
  type caffe (line 13) | namespace caffe {
    function NetNeedsUpgrade (line 15) | bool NetNeedsUpgrade(const NetParameter& net_param) {
    function NetNeedsV0ToV1Upgrade (line 19) | bool NetNeedsV0ToV1Upgrade(const NetParameter& net_param) {
    function NetNeedsV1ToV2Upgrade (line 28) | bool NetNeedsV1ToV2Upgrade(const NetParameter& net_param) {
    function UpgradeV0Net (line 32) | bool UpgradeV0Net(const NetParameter& v0_net_param_padding_layers,
    function UpgradeV0PaddingLayers (line 59) | void UpgradeV0PaddingLayers(const NetParameter& param,
    function UpgradeV0LayerParameter (line 118) | bool UpgradeV0LayerParameter(const V1LayerParameter& v0_layer_connection,
    function V1LayerParameter_LayerType (line 470) | V1LayerParameter_LayerType UpgradeV0LayerType(const string& type) {
    function NetNeedsDataUpgrade (line 525) | bool NetNeedsDataUpgrade(const NetParameter& net_param) {
    function UpgradeNetDataTransformation (line 578) | void UpgradeNetDataTransformation(NetParameter* net_param) {
    function UpgradeNetAsNeeded (line 586) | bool UpgradeNetAsNeeded(const string& param_file, NetParameter* param) {
    function UpgradeV1Net (line 633) | bool UpgradeV1Net(const NetParameter& v1_net_param, NetParameter* net_...
    function UpgradeV1LayerParameter (line 653) | bool UpgradeV1LayerParameter(const V1LayerParameter& v1_layer_param,
    function ReadNetParamsFromTextFileOrDie (line 930) | void ReadNetParamsFromTextFileOrDie(const string& param_file,
    function ReadNetParamsFromBinaryFileOrDie (line 937) | void ReadNetParamsFromBinaryFileOrDie(const string& param_file,

FILE: src/gtest/gtest-all.cpp
  type testing (line 113) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  function IsSubstringPred (line 2534) | bool IsSubstringPred(const char* needle, const char* haystack) {
  function IsSubstringPred (line 2541) | bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) {
  function IsSubstringPred (line 2550) | bool IsSubstringPred(const StringType& needle,
  function AssertionResult (line 2560) | AssertionResult IsSubstringImpl(
  function AssertionResult (line 2583) | AssertionResult IsSubstring(
  function AssertionResult (line 2589) | AssertionResult IsSubstring(
  function AssertionResult (line 2595) | AssertionResult IsNotSubstring(
  function AssertionResult (line 2601) | AssertionResult IsNotSubstring(
  function AssertionResult (line 2607) | AssertionResult IsSubstring(
  function AssertionResult (line 2613) | AssertionResult IsNotSubstring(
  function AssertionResult (line 2620) | AssertionResult IsSubstring(
  function AssertionResult (line 2626) | AssertionResult IsNotSubstring(
  type internal (line 2633) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  function TestPartResult (line 3089) | const TestPartResult& TestResult::GetTestPartResult(int i) const {
  function TestProperty (line 3098) | const TestProperty& TestResult::GetTestProperty(int i) const {
  function TestPartFatallyFailed (line 3165) | static bool TestPartFatallyFailed(const TestPartResult& result) {
  function TestPartNonfatallyFailed (line 3175) | static bool TestPartNonfatallyFailed(const TestPartResult& result) {
  type internal (line 3233) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  function FormatCxxExceptionMessage (line 3335) | static internal::String FormatCxxExceptionMessage(const char* description,
  class GoogleTestFailureException (line 3357) | class GoogleTestFailureException : public ::std::runtime_error {
    method GoogleTestFailureException (line 3359) | explicit GoogleTestFailureException(const TestPartResult& failure)
  type internal (line 3364) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  type internal (line 3513) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  class TestNameIs (line 3578) | class TestNameIs {
    method TestNameIs (line 3583) | explicit TestNameIs(const char* name)
  type internal (line 3597) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  function TestInfo (line 3713) | const TestInfo* TestCase::GetTestInfo(int i) const {
  function TestInfo (line 3720) | TestInfo* TestCase::GetMutableTestInfo(int i) {
  function FormatCountableNoun (line 3782) | static internal::String FormatCountableNoun(int count,
  function FormatTestCount (line 3790) | static internal::String FormatTestCount(int test_count) {
  function FormatTestCaseCount (line 3795) | static internal::String FormatTestCaseCount(int test_case_count) {
  function PrintTestPartResultToString (line 3821) | static internal::String PrintTestPartResultToString(
  function PrintTestPartResult (line 3831) | static void PrintTestPartResult(const TestPartResult& test_part_result) {
  type internal (line 3851) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  function TestEventListener (line 4873) | TestEventListener* TestEventListeners::Release(TestEventListener* listen...
  function TestEventListener (line 4883) | TestEventListener* TestEventListeners::repeater() { return repeater_; }
  function UnitTest (line 4936) | UnitTest * UnitTest::GetInstance() {
  function TestCase (line 5011) | const TestCase* UnitTest::GetTestCase(int i) const {
  function TestCase (line 5017) | TestCase* UnitTest::GetMutableTestCase(int i) {
  function TestEventListeners (line 5023) | TestEventListeners& UnitTest::listeners() {
  function Environment (line 5037) | Environment* UnitTest::AddEnvironment(Environment* env) {
  function TestCase (line 5189) | const TestCase* UnitTest::current_test_case() const {
  function TestInfo (line 5197) | const TestInfo* UnitTest::current_test_info() const {
  type internal (line 5240) | namespace internal {
    function AssertionResult (line 2640) | AssertionResult HRESULTFailureHelper(const char* expr,
    function AssertionResult (line 2681) | AssertionResult IsHRESULTSuccess(const char* expr, long hr) {  // NOLINT
    function AssertionResult (line 2688) | AssertionResult IsHRESULTFailure(const char* expr, long hr) {  // NOLINT
    function UInt32 (line 2724) | inline UInt32 ChopLowBits(UInt32* bits, int n) {
    function IsUtf16SurrogatePair (line 2778) | inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) {
    function UInt32 (line 2784) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
    function String (line 2807) | String WideStringToUtf8(const wchar_t* str, int num_chars) {
    function String (line 2833) | String String::ShowWideCString(const wchar_t * wide_c_str) {
    function String (line 2841) | String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) {
    function AssertionResult (line 2863) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
    function AssertionResult (line 2879) | AssertionResult CmpHelperSTRNE(const char* s1_expression,
    function String (line 3003) | String String::Format(const char * format, ...) {
    function String (line 3038) | String StringStreamToString(::std::stringstream* ss) {
    function String (line 3058) | String AppendUserMessage(const String& gtest_msg,
    function ReportFailureInUnknownLocation (line 3235) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
    function Result (line 3374) | Result HandleSehExceptionsInMethodIfSupported(
    function Result (line 3401) | Result HandleExceptionsInMethodIfSupported(
    function TestInfo (line 3532) | TestInfo* MakeAndRegisterTestInfo(
    function ReportInvalidTestCaseType (line 3548) | void ReportInvalidTestCaseType(const char* test_case_name,
    type GTestColor (line 3853) | enum GTestColor {
    function WORD (line 3863) | WORD GetColorAttribute(GTestColor color) {
    function ShouldUseColor (line 3888) | bool ShouldUseColor(bool stdout_is_tty) {
    function ColoredPrintf (line 3923) | void ColoredPrintf(GTestColor color, const char* fmt, ...) {
    function PrintFullTestCommentIfPresent (line 3969) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
    class PrettyUnitTestResultPrinter (line 3989) | class PrettyUnitTestResultPrinter : public TestEventListener {
      method PrettyUnitTestResultPrinter (line 3991) | PrettyUnitTestResultPrinter() {}
      method PrintTestName (line 3992) | static void PrintTestName(const char * test_case, const char * test) {
      method OnTestProgramStart (line 3997) | virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsSetUpEnd (line 4000) | virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {}
      method OnEnvironmentsTearDownEnd (line 4007) | virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/...
      method OnTestProgramEnd (line 4009) | virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {}
    class TestEventRepeater (line 4200) | class TestEventRepeater : public TestEventListener {
      method TestEventRepeater (line 4202) | TestEventRepeater() : forwarding_enabled_(true) {}
      method forwarding_enabled (line 4209) | bool forwarding_enabled() const { return forwarding_enabled_; }
      method set_forwarding_enabled (line 4210) | void set_forwarding_enabled(bool enable) { forwarding_enabled_ = ena...
    function TestEventListener (line 4245) | TestEventListener* TestEventRepeater::Release(TestEventListener *liste...
    class XmlUnitTestResultPrinter (line 4313) | class XmlUnitTestResultPrinter : public EmptyTestEventListener {
      method IsNormalizableWhitespace (line 4322) | static bool IsNormalizableWhitespace(char c) {
      method IsValidXmlCharacter (line 4327) | static bool IsValidXmlCharacter(char c) {
      method String (line 4341) | static String EscapeXmlAttribute(const char* str) {
      method String (line 4346) | static String EscapeXmlText(const char* str) { return EscapeXml(str,...
    function String (line 4427) | String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_at...
    function string (line 4472) | string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const stri...
    function FormatTimeInMillisAsSeconds (line 4499) | std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) {
    function String (line 4617) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
    class StreamingListener (line 4633) | class StreamingListener : public EmptyTestEventListener {
      method StreamingListener (line 4638) | StreamingListener(const string& host, const string& port)
      method OnTestProgramStart (line 4649) | void OnTestProgramStart(const UnitTest& /* unit_test */) {
      method OnTestProgramEnd (line 4653) | void OnTestProgramEnd(const UnitTest& unit_test) {
      method OnTestIterationStart (line 4663) | void OnTestIterationStart(const UnitTest& /* unit_test */, int itera...
      method OnTestIterationEnd (line 4668) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration ...
      method OnTestCaseStart (line 4674) | void OnTestCaseStart(const TestCase& test_case) {
      method OnTestCaseEnd (line 4678) | void OnTestCaseEnd(const TestCase& test_case) {
      method OnTestStart (line 4684) | void OnTestStart(const TestInfo& test_info) {
      method OnTestEnd (line 4688) | void OnTestEnd(const TestInfo& test_info) {
      method OnTestPartResult (line 4695) | void OnTestPartResult(const TestPartResult& test_part_result) {
      method CloseConnection (line 4710) | void CloseConnection() {
      method Send (line 4719) | void Send(const string& message) {
    function string (line 4743) | string StreamingListener::UrlEncode(const char* str) {
    function String (line 4838) | String OsStackTraceGetter::CurrentStackTrace(int, int) {
    class TestCaseNameIs (line 5372) | class TestCaseNameIs {
      method TestCaseNameIs (line 5375) | explicit TestCaseNameIs(const String& name)
    function TestCase (line 5399) | TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
    function SetUpEnvironment (line 5436) | static void SetUpEnvironment(Environment* env) { env->SetUp(); }
    function TearDownEnvironment (line 5437) | static void TearDownEnvironment(Environment* env) { env->TearDown(); }
    function WriteToShardStatusFileIfNeeded (line 5584) | void WriteToShardStatusFileIfNeeded() {
    function ShouldShard (line 5606) | bool ShouldShard(const char* total_shards_env,
    function Int32 (line 5651) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
    function ShouldRunTestOnShard (line 5669) | bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_...
    function OsStackTraceGetterInterface (line 5770) | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
    function TestResult (line 5780) | TestResult* UnitTestImpl::current_test_result() {
    function String (line 5821) | String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/,
    class ClassUniqueToAlwaysTrue (line 5831) | class ClassUniqueToAlwaysTrue {}
    function IsTrue (line 5834) | bool IsTrue(bool condition) { return condition; }
    function AlwaysTrue (line 5836) | bool AlwaysTrue() {
    function SkipPrefix (line 5849) | bool SkipPrefix(const char* prefix, const char** pstr) {
    function ParseBoolFlag (line 5901) | bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
    function ParseInt32Flag (line 5918) | bool ParseInt32Flag(const char* str, const char* flag, Int32* value) {
    function ParseStringFlag (line 5935) | bool ParseStringFlag(const char* str, const char* flag, String* value) {
    function HasGoogleTestFlagPrefix (line 5953) | static bool HasGoogleTestFlagPrefix(const char* str) {
    function PrintColorEncoded (line 5973) | static void PrintColorEncoded(const char* str) {
    function ParseGoogleTestFlagsOnlyImpl (line 6075) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
    function ParseGoogleTestFlagsOnly (line 6145) | void ParseGoogleTestFlagsOnly(int* argc, char** argv) {
    function ParseGoogleTestFlagsOnly (line 6148) | void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) {
    function InitGoogleTestImpl (line 6157) | void InitGoogleTestImpl(int* argc, CharType** argv) {
  function InitGoogleTest (line 6191) | void InitGoogleTest(int* argc, char** argv) {
  function InitGoogleTest (line 6197) | void InitGoogleTest(int* argc, wchar_t** argv) {
  type testing (line 6265) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  type testing (line 7489) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  type testing (line 7869) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  type testing (line 8597) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  type testing (line 8944) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
  type testing (line 9042) | namespace testing {
    function ScopedFakeTestPartResultReporter (line 124) | class GTEST_API_ ScopedFakeTestPartResultReporter
    function AssertionResult (line 2510) | AssertionResult CmpHelperSTRCASENE(const char* s1_expression,
    type internal (line 6293) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 6334) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function SplitString (line 7294) | static void SplitString(const ::std::string& str, char delimiter,
    function GetStatusFileDescriptor (line 7315) | int GetStatusFileDescriptor(unsigned int parent_process_id,
    function InternalRunDeathTestFlag (line 7380) | InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() {
    type internal (line 7490) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 7870) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function PrintByteSegmentInObjectTo (line 8612) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t...
    function PrintBytesInObjectToImpl (line 8631) | void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t c...
    type internal2 (line 8656) | namespace internal2 {
      function PrintBytesInObjectTo (line 8663) | void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count,
    type internal (line 8670) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    function TestPartResult (line 8972) | const TestPartResult& TestPartResultArray::GetTestPartResult(int index...
    type internal (line 8986) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {
    type internal (line 9043) | namespace internal {
      function String (line 6340) | static String ExitSummary(int exit_code) {
      function ExitedUnsuccessfully (line 6366) | bool ExitedUnsuccessfully(int exit_status) {
      function String (line 6375) | static String DeathTestThreadWarning(size_t thread_count) {
      type DeathTestOutcome (line 6402) | enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }
      function DeathTestAbort (line 6409) | void DeathTestAbort(const String& message) {
      function String (line 6460) | String GetLastErrnoDescription() {
      function FailFromInternalError (line 6468) | static void FailFromInternalError(int fd) {
      class DeathTestImpl (line 6518) | class DeathTestImpl : public DeathTest {
        method DeathTestImpl (line 6520) | DeathTestImpl(const char* a_statement, const RE* a_regex)
        method RE (line 6536) | const RE* regex() const { return regex_; }
        method spawned (line 6537) | bool spawned() const { return spawned_; }
        method set_spawned (line 6538) | void set_spawned(bool is_spawned) { spawned_ = is_spawned; }
        method status (line 6539) | int status() const { return status_; }
        method set_status (line 6540) | void set_status(int a_status) { status_ = a_status; }
        method DeathTestOutcome (line 6541) | DeathTestOutcome outcome() const { return outcome_; }
        method set_outcome (line 6542) | void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outc...
        method read_fd (line 6543) | int read_fd() const { return read_fd_; }
        method set_read_fd (line 6544) | void set_read_fd(int fd) { read_fd_ = fd; }
        method write_fd (line 6545) | int write_fd() const { return write_fd_; }
        method set_write_fd (line 6546) | void set_write_fd(int fd) { write_fd_ = fd; }
      function FormatDeathTestOutput (line 6649) | static ::std::string FormatDeathTestOutput(const ::std::string& outp...
      class WindowsDeathTest (line 6764) | class WindowsDeathTest : public DeathTestImpl {
        method WindowsDeathTest (line 6766) | WindowsDeathTest(const char* a_statement,
      class ForkingDeathTest (line 6936) | class ForkingDeathTest : public DeathTestImpl {
        method set_child_pid (line 6944) | void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; }
      class NoExecDeathTest (line 6973) | class NoExecDeathTest : public ForkingDeathTest {
        method NoExecDeathTest (line 6975) | NoExecDeathTest(const char* a_statement, const RE* a_regex) :
      class ExecDeathTest (line 7027) | class ExecDeathTest : public ForkingDeathTest {
        method ExecDeathTest (line 7029) | ExecDeathTest(const char* a_statement, const RE* a_regex,
      class Arguments (line 7041) | class Arguments {
        method Arguments (line 7043) | Arguments() {
        method AddArgument (line 7053) | void AddArgument(const char* argument) {
        method AddArguments (line 7058) | void AddArguments(const ::std::vector<Str>& arguments) {
      type ExecDeathTestArgs (line 7074) | struct ExecDeathTestArgs {
      function ExecDeathTestChildMain (line 7096) | static int ExecDeathTestChildMain(void* child_arg) {
      function StackLowerThanAddress (line 7136) | bool StackLowerThanAddress(const void* ptr) {
      function StackGrowsDown (line 7141) | bool StackGrowsDown() {
      function pid_t (line 7149) | static pid_t ExecDeathTestFork(char* const* argv, int close_fd) {
      function IsPathSeparator (line 7518) | static bool IsPathSeparator(char c) {
      function FilePath (line 7527) | FilePath FilePath::GetCurrentDir() {
      function FilePath (line 7545) | FilePath FilePath::RemoveExtension(const char* extension) const {
      function FilePath (line 7575) | FilePath FilePath::RemoveDirectoryName() const {
      function FilePath (line 7586) | FilePath FilePath::RemoveFileName() const {
      function FilePath (line 7603) | FilePath FilePath::MakeFileName(const FilePath& directory,
      function FilePath (line 7618) | FilePath FilePath::ConcatPaths(const FilePath& directory,
      function FilePath (line 7706) | FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
      function FilePath (line 7766) | FilePath FilePath::RemoveTrailingPathSeparator() const {
      function GetThreadCount (line 7885) | size_t GetThreadCount() {
      function GetThreadCount (line 7904) | size_t GetThreadCount() {
      function IsInSet (line 7979) | bool IsInSet(char ch, const char* str) {
      function IsAsciiDigit (line 7986) | bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; }
      function IsAsciiPunct (line 7987) | bool IsAsciiPunct(char ch) {
      function IsRepeat (line 7990) | bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); }
      function IsAsciiWhiteSpace (line 7991) | bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); }
      function IsAsciiWordChar (line 7992) | bool IsAsciiWordChar(char ch) {
      function IsValidEscape (line 7998) | bool IsValidEscape(char c) {
      function AtomMatchesChar (line 8004) | bool AtomMatchesChar(bool escaped, char pattern_char, char ch) {
      function String (line 8026) | String FormatRegexSyntaxError(const char* regex, int index) {
      function ValidateRegex (line 8033) | bool ValidateRegex(const char* regex) {
      function MatchRepetitionAndRegexAtHead (line 8096) | bool MatchRepetitionAndRegexAtHead(
      function MatchRegexAtHead (line 8123) | bool MatchRegexAtHead(const char* regex, const char* str) {
      function MatchRegexAnywhere (line 8159) | bool MatchRegexAnywhere(const char* regex, const char* str) {
      function FormatFileLocation (line 8232) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int li...
      function FormatCompilerIndependentFileLocation (line 8250) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(
      class CapturedStream (line 8289) | class CapturedStream {
        method CapturedStream (line 8292) | CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
        method String (line 8326) | String GetCapturedString() {
      function String (line 8363) | String CapturedStream::ReadEntireFile(FILE* file) {
      function CaptureStream (line 8393) | void CaptureStream(int fd, const char* stream_name, CapturedStream**...
      function String (line 8402) | String GetCapturedStream(CapturedStream** captured_stream) {
      function CaptureStdout (line 8412) | void CaptureStdout() {
      function CaptureStderr (line 8417) | void CaptureStderr() {
      function String (line 8422) | String GetCapturedStdout() { return GetCapturedStream(&g_captured_st...
      function String (line 8425) | String GetCapturedStderr() { return GetCapturedStream(&g_captured_st...
      type posix (line 8440) | namespace posix {
        function Abort (line 8441) | void Abort() {
      function String (line 8451) | static String FlagToEnvVar(const char* flag) {
      function ParseInt32 (line 8466) | bool ParseInt32(const Message& src_text, const char* str, Int32* val...
      function BoolFromGTestEnv (line 8508) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
      function Int32 (line 8518) | Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
      type CharFormat (line 8677) | enum CharFormat {
      function IsPrintableAscii (line 8686) | inline bool IsPrintableAscii(wchar_t c) {
      function CharFormat (line 8695) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
      function CharFormat (line 8741) | static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) {
      function CharFormat (line 8756) | static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) {
      function PrintCharAndCodeTo (line 8765) | void PrintCharAndCodeTo(Char c, ostream* os) {
      function PrintTo (line 8790) | void PrintTo(unsigned char c, ::std::ostream* os) {
      function PrintTo (line 8793) | void PrintTo(signed char c, ::std::ostream* os) {
      function PrintTo (line 8799) | void PrintTo(wchar_t wc, ostream* os) {
      function PrintCharsAsStringTo (line 8806) | static void PrintCharsAsStringTo(const char* begin, size_t len, ostr...
      function UniversalPrintArray (line 8823) | void UniversalPrintArray(const char* begin, size_t len, ostream* os) {
      function PrintWideCharsAsStringTo (line 8830) | static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len,
      function PrintTo (line 8848) | void PrintTo(const char* s, ostream* os) {
      function PrintTo (line 8865) | void PrintTo(const wchar_t* s, ostream* os) {
      function PrintStringTo (line 8877) | void PrintStringTo(const ::string& s, ostream* os) {
      function PrintStringTo (line 8882) | void PrintStringTo(const ::std::string& s, ostream* os) {
      function PrintWideStringTo (line 8888) | void PrintWideStringTo(const ::wstring& s, ostream* os) {
      function PrintWideStringTo (line 8894) | void PrintWideStringTo(const ::std::wstring& s, ostream* os) {

FILE: src/gtest/gtest.h
  function namespace (line 663) | namespace std {
  function GTEST_1_TUPLE_ (line 744) | GTEST_1_TUPLE_(T) {
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 764) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 805) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 840) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 879) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 921) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 966) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 1013) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 1063) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 1115) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function GTEST_DECLARE_TUPLE_AS_FRIEND_ (line 1171) | GTEST_DECLARE_TUPLE_AS_FRIEND_
  function make_tuple (line 1214) | GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) {
  function make_tuple (line 1219) | GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) {
  function make_tuple (line 1224) | GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1230) | GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1236) | GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1242) | GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1248) | GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1254) | GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  function make_tuple (line 1261) | GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2,
  type typename (line 1306) | typedef typename gtest_internal::TupleElement<
  function namespace (line 1314) | namespace gtest_internal {
  function namespace (line 1454) | namespace gtest_internal {
  function namespace (line 1734) | namespace testing {
  function LogToStderr (line 1989) | inline void LogToStderr() {}
  function FlushInfoLog (line 1990) | inline void FlushInfoLog() { fflush(NULL); }
  function To (line 2044) | To ImplicitCast_(To x) { return x; }
  function To (line 2068) | To DownCast_(From* f) {  // so we only accept pointers
  function SleepMilliseconds (line 2133) | inline void SleepMilliseconds(int n) {
  function class (line 2147) | class Notification {
  function class (line 2174) | class ThreadWithParamBase {
  function Join (line 2222) | void Join() {
  function virtual (line 2229) | virtual void Run() {
  function class (line 2266) | class MutexBase {
  function class (line 2310) | class Mutex : public MutexBase {
  function class (line 2327) | class GTestMutexLock {
  type GTestMutexLock (line 2340) | typedef GTestMutexLock MutexLock;
  function class (line 2348) | class ThreadLocalValueHolderBase {
  function DeleteThreadLocalValue (line 2355) | inline void DeleteThreadLocalValue(void* value_holder) {
  function explicit (line 2393) | explicit ThreadLocal(const T& value) : key_(CreateKey()),
  function T (line 2405) | T* pointer() { return GetOrCreateValue(); }
  function T (line 2406) | const T* pointer() const { return GetOrCreateValue(); }
  function set (line 2408) | void set(const T& value) { *pointer() = value; }
  function T (line 2416) | T* pointer() { return &value_; }
  function pthread_key_t (line 2423) | static pthread_key_t CreateKey() {
  function T (line 2432) | T* GetOrCreateValue() const {
  function class (line 2461) | class Mutex {
  function class (line 2472) | class GTestMutexLock {
  type GTestMutexLock (line 2477) | typedef GTestMutexLock MutexLock;
  function explicit (line 2483) | explicit ThreadLocal(const T& value) : value_(value) {}
  function T (line 2484) | T* pointer() { return &value_; }
  function T (line 2485) | const T* pointer() const { return &value_; }
  function set (line 2487) | void set(const T& value) { value_ = value; }
  type bool_constant (line 2526) | typedef bool_constant<bool_value> type;
  type bool_constant (line 2531) | typedef bool_constant<false> false_type;
  type bool_constant (line 2532) | typedef bool_constant<true> true_type;
  type typename (line 2542) | typedef typename Iterator::value_type value_type;
  type T (line 2547) | typedef T value_type;
  type T (line 2552) | typedef T value_type;
  type __int64 (line 2559) | typedef __int64 BiggestInt;
  type BiggestInt (line 2563) | typedef long long BiggestInt;
  function IsAlpha (line 2573) | inline bool IsAlpha(char ch) {
  function IsAlNum (line 2576) | inline bool IsAlNum(char ch) {
  function IsDigit (line 2579) | inline bool IsDigit(char ch) {
  function IsLower (line 2582) | inline bool IsLower(char ch) {
  function IsSpace (line 2585) | inline bool IsSpace(char ch) {
  function IsUpper (line 2588) | inline bool IsUpper(char ch) {
  function IsXDigit (line 2591) | inline bool IsXDigit(char ch) {
  function ToLower (line 2595) | inline char ToLower(char ch) {
  function ToUpper (line 2598) | inline char ToUpper(char ch) {
  function namespace (line 2608) | namespace posix {
  type UInt (line 2776) | typedef unsigned int UInt;
  type __int64 (line 2785) | typedef __int64 Int;
  type UInt (line 2786) | typedef unsigned __int64 UInt;
  type Int (line 2788) | typedef long long Int;
  type UInt (line 2789) | typedef unsigned long long UInt;
  type TypeWithSize (line 2794) | typedef TypeWithSize<4>::Int Int32;
  type TypeWithSize (line 2795) | typedef TypeWithSize<4>::UInt UInt32;
  type TypeWithSize (line 2796) | typedef TypeWithSize<8>::Int Int64;
  type TypeWithSize (line 2797) | typedef TypeWithSize<8>::UInt UInt64;
  type TypeWithSize (line 2798) | typedef TypeWithSize<8>::Int TimeInMillis;
  function namespace (line 2904) | namespace testing {
  function operator (line 3104) | bool operator<(const String& rhs) const { return Compare(rhs) < 0; }
  function namespace (line 3244) | namespace testing {
  function namespace (line 3465) | namespace testing {
  type internal (line 4162) | typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, ...
  type Types (line 4169) | struct Types
  type internal (line 4198) | typedef internal::Types1<T1> type;
  type internal (line 4214) | typedef internal::Types2<T1, T2> type;
  type internal (line 4229) | typedef internal::Types3<T1, T2, T3> type;
  type internal (line 4244) | typedef internal::Types4<T1, T2, T3, T4> type;
  type internal (line 4259) | typedef internal::Types5<T1, T2, T3, T4, T5> type;
  type internal (line 4275) | typedef internal::Types6<T1, T2, T3, T4, T5, T6> type;
  type internal (line 4291) | typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type;
  type internal (line 4306) | typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type;
  type internal (line 4321) | typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type;
  function namespace (line 5028) | namespace internal {
  type Templates4 (line 5098) | typedef Templates4<T2, T3, T4, T5> Tail;
  type Templates5 (line 5105) | typedef Templates5<T2, T3, T4, T5, T6> Tail;
  type Templates6 (line 5113) | typedef Templates6<T2, T3, T4, T5, T6, T7> Tail;
  type Templates7 (line 5121) | typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail;
  type Templates8 (line 5129) | typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail;
  type Templates9 (line 5138) | typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail;
  type Templates10 (line 5147) | typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail;
  type Templates11 (line 5156) | typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail;
  type Templates12 (line 5166) | typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ...
  type Templates13 (line 5176) | typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
  type Templates14 (line 5187) | typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates15 (line 5199) | typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates16 (line 5211) | typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates17 (line 5223) | typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates18 (line 5236) | typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates19 (line 5249) | typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates20 (line 5262) | typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates21 (line 5276) | typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates22 (line 5290) | typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates23 (line 5304) | typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates24 (line 5319) | typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates25 (line 5334) | typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates26 (line 5349) | typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates27 (line 5365) | typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates28 (line 5382) | typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates29 (line 5399) | typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates30 (line 5417) | typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates31 (line 5435) | typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates32 (line 5453) | typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates33 (line 5472) | typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates34 (line 5491) | typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates35 (line 5510) | typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates36 (line 5530) | typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates37 (line 5550) | typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates38 (line 5570) | typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates39 (line 5591) | typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates40 (line 5612) | typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates41 (line 5633) | typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates42 (line 5656) | typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates43 (line 5679) | typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates44 (line 5702) | typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates45 (line 5726) | typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates46 (line 5750) | typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates47 (line 5774) | typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates48 (line 5799) | typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates49 (line 5824) | typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, ...
  type Templates (line 5877) | struct Templates
  type Types1 (line 6710) | typedef Types1<T> type;
  function GTestStreamToHelper (line 6776) | void GTestStreamToHelper(std::ostream* os, const T& val) {
  function namespace (line 6781) | namespace proto2 { class Message; }
  function namespace (line 6783) | namespace testing {
  type IsContainer (line 7607) | typedef int IsContainer;
  type IsNotContainer (line 7615) | typedef char IsNotContainer;
  function IsContainerTest (line 7617) | IsContainerTest(long /* dummy */) { return '\0'; }
  type EnableIf (line 7624) | struct EnableIf
  type type (line 7624) | typedef void type;
  function ArrayEq (line 7637) | bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; }
  function ArrayEq (line 7641) | bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) {
  function CopyArray (line 7677) | void CopyArray(const T& from, U* to) { *to = from; }
  function CopyArray (line 7681) | void CopyArray(const T(&from)[N], U(*to)[N]) {
  type RelationToSource (line 7697) | enum RelationToSource {
  type Element (line 7716) | typedef Element* iterator;
  type Element (line 7717) | typedef const Element* const_iterator;
  function namespace (line 7989) | namespace testing {
  function namespace (line 8255) | namespace testing {
  function namespace (line 8547) | namespace testing {
  function StreamHelper (line 8695) | void StreamHelper(internal::true_type /*dummy*/, T* pointer) {
  function StreamHelper (line 8703) | void StreamHelper(internal::false_type /*dummy*/, const T& value) {
  function class (line 8885) | class BaseTest : public ::testing::Test {
  function namespace (line 9030) | namespace testing {
  function T (line 9126) | T* get() const { return value_; }
  function depart (line 9148) | void depart() {
  function capture (line 9152) | void capture(T* ptr) {
  function namespace (line 9291) | namespace testing {
  function namespace (line 9398) | namespace testing_internal {
  function namespace (line 9435) | namespace testing {
  function PrintTo (line 9643) | inline void PrintTo(const ::string& s, ::std::ostream* os) {
  function PrintTo (line 9649) | inline void PrintTo(const ::std::string& s, ::std::ostream* os) {
  function PrintTo (line 9656) | inline void PrintTo(const ::wstring& s, ::std::ostream* os) {
  function PrintTo (line 9663) | inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) {
  function PrintTo (line 9682) | inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) {
  function Print (line 9776) | static void Print(const T& value, ::std::ostream* os) {
  function Print (line 9844) | static void Print(const T& value, ::std::ostream* os) {
  function ostream (line 9862) | ostream* os) {
  function UniversalTersePrint (line 9865) | inline void UniversalTersePrint(const char* str, ::std::ostream* os) {
  function UniversalTersePrint (line 9872) | inline void UniversalTersePrint(char* str, ::std::ostream* os) {
  function ostream (line 9881) | ostream* os) {
  type std (line 9886) | typedef ::std::vector<string> Strings;
  function PrintPrefixTo (line 9900) | void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
  function TersePrintPrefixToStrings (line 9910) | void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
  type TuplePrefixPrinter (line 9920) | struct TuplePrefixPrinter
  function PrintPrefixTo (line 9922) | void PrintPrefixTo(const Tuple&, ::std::ostream*) {}
  function TersePrintPrefixToStrings (line 9925) | void TersePrintPrefixToStrings(const Tuple&, Strings*) {}
  type TuplePrefixPrinter (line 9933) | struct TuplePrefixPrinter
  function PrintPrefixTo (line 9935) | void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
  function TersePrintPrefixToStrings (line 9941) | void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) {
  function ostream (line 9951) | ostream* os) {
  function string (line 9973) | string PrintToString(const T& value) {
  function namespace (line 9985) | namespace testing {
  function CalculateEndIndex (line 10176) | static int CalculateEndIndex(const T& begin,
  function virtual (line 10207) | virtual ~ValuesInIteratorRangeGenerator() {}
  function virtual (line 10209) | virtual ParamIteratorInterface<T>* Begin() const {
  function virtual (line 10212) | virtual ParamIteratorInterface<T>* End() const {
  function class (line 10219) | class Iterator : public ParamIteratorInterface<T> {
  function explicit (line 10290) | explicit ParameterizedTestFactory(ParamType parameter) :
  function virtual (line 10292) | virtual Test* CreateTest() {
  function virtual (line 10331) | virtual TestFactoryBase* CreateTestFactory(ParamType parameter) {
  function class (line 10349) | class ParameterizedTestCaseInfoBase {
  type ParamGenerator (line 10385) | typedef ParamGenerator<ParamType>(GeneratorCreationFunc)();
  function explicit (line 10387) | explicit ParameterizedTestCaseInfo(const char* name)
  function AddTestPattern (line 10400) | void AddTestPattern(const char* test_case_name,
  function AddTestCaseInstantiation (line 10409) | int AddTestCaseInstantiation(const string& instantiation_name,
  function virtual (line 10421) | virtual void RegisterTests() {
  type TestInfo (line 10459) | struct TestInfo {
  type std (line 10471) | typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer;
  type std (line 10474) | typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> >
  function class (line 10490) | class ParameterizedTestCaseRegistry {
  function namespace (line 10608) | namespace testing {
  function virtual (line 13397) | virtual ~CartesianProductGenerator2() {}
  function virtual (line 13399) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 13402) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 13419) | virtual ~Iterator() {}
  function virtual (line 13421) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 13426) | virtual void Advance() {
  function virtual (line 13435) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 13438) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 13439) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 13468) | void ComputeCurrentValue() {
  function virtual (line 13512) | virtual ~CartesianProductGenerator3() {}
  function virtual (line 13514) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 13518) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 13538) | virtual ~Iterator() {}
  function virtual (line 13540) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 13545) | virtual void Advance() {
  function virtual (line 13558) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 13561) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 13562) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 13595) | void ComputeCurrentValue() {
  function virtual (line 13645) | virtual ~CartesianProductGenerator4() {}
  function virtual (line 13647) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 13651) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 13675) | virtual ~Iterator() {}
  function virtual (line 13677) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 13682) | virtual void Advance() {
  function virtual (line 13699) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 13702) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 13703) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 13740) | void ComputeCurrentValue() {
  function virtual (line 13796) | virtual ~CartesianProductGenerator5() {}
  function virtual (line 13798) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 13802) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 13829) | virtual ~Iterator() {}
  function virtual (line 13831) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 13836) | virtual void Advance() {
  function virtual (line 13857) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 13860) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 13861) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 13902) | void ComputeCurrentValue() {
  type std (line 13959) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType;
  function virtual (line 13966) | virtual ~CartesianProductGenerator6() {}
  function virtual (line 13968) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 13972) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 14002) | virtual ~Iterator() {}
  function virtual (line 14004) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 14009) | virtual void Advance() {
  function virtual (line 14034) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 14037) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 14038) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 14083) | void ComputeCurrentValue() {
  type std (line 14145) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType;
  function virtual (line 14152) | virtual ~CartesianProductGenerator7() {}
  function virtual (line 14154) | virtual ParamIteratorInterface<ParamType>* Begin() const {
  function virtual (line 14159) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 14192) | virtual ~Iterator() {}
  function virtual (line 14194) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 14199) | virtual void Advance() {
  function virtual (line 14228) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 14231) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 14232) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 14281) | void ComputeCurrentValue() {
  type std (line 14348) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType;
  function virtual (line 14364) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 14401) | virtual ~Iterator() {}
  function virtual (line 14403) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 14408) | virtual void Advance() {
  function virtual (line 14441) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 14444) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 14445) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 14498) | void ComputeCurrentValue() {
  type std (line 14570) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType;
  function virtual (line 14586) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 14626) | virtual ~Iterator() {}
  function virtual (line 14628) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 14633) | virtual void Advance() {
  function virtual (line 14670) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 14673) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 14674) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 14731) | void ComputeCurrentValue() {
  type std (line 14809) | typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Param...
  function virtual (line 14826) | virtual ParamIteratorInterface<ParamType>* End() const {
  function virtual (line 14869) | virtual ~Iterator() {}
  function virtual (line 14871) | virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const {
  function virtual (line 14876) | virtual void Advance() {
  function virtual (line 14917) | virtual ParamIteratorInterface<ParamType>* Clone() const {
  function virtual (line 14920) | virtual const ParamType* Current() const { return &current_value_; }
  function virtual (line 14921) | virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const {
  function ComputeCurrentValue (line 14982) | void ComputeCurrentValue() {
  function namespace (line 15377) | namespace testing {
  function internal (line 16400) | inline internal::ParamGenerator<bool> Bool() {
  function namespace (line 16698) | namespace testing {
  function class (line 16780) | class GTEST_API_ TestPartResultArray {
  function class (line 16800) | class TestPartResultReporterInterface {
  function namespace (line 16807) | namespace internal {
  type testing (line 16890) | typedef testing::Types<char, int, unsigned int> MyTypes;
  type testing (line 16973) | typedef testing::Types<char, int, unsigned int> MyTypes;
  function namespace (line 17107) | namespace testing {
  function namespace (line 18569) | namespace internal {
  function class (line 18616) | class GTEST_API_ AssertHelper {
  function virtual (line 18696) | virtual ~WithParamInterface() {}

FILE: src/gtest/gtest_main.cc
  function GTEST_API_ (line 34) | GTEST_API_ int main(int argc, char **argv) {

FILE: tools/caffe.cpp
  function BrewFunction (line 66) | static BrewFunction GetBrewFunction(const caffe::string& name) {
  function get_gpus (line 81) | static void get_gpus(vector<int>* gpus) {
  function device_query (line 110) | int device_query() {
  function CopyLayers (line 124) | void CopyLayers(caffe::Solver<float>* solver, const std::string& model_l...
  function GetRequestedAction (line 138) | caffe::SolverAction::Enum GetRequestedAction(
  function train (line 153) | int train() {
  function test (line 221) | int test() {
  function time (line 289) | int time() {
  function main (line 377) | int main(int argc, char** argv) {

FILE: tools/compute_image_mean.cpp
  function main (line 24) | int main(int argc, char** argv) {

FILE: tools/convert_imageset.cpp
  function main (line 45) | int main(int argc, char** argv) {

FILE: tools/device_query.cpp
  function main (line 3) | int main(int argc, char** argv) {

FILE: tools/extra/extract_seconds.py
  function extract_datetime_from_line (line 6) | def extract_datetime_from_line(line, year):
  function get_log_created_year (line 22) | def get_log_created_year(input_file):
  function get_start_time (line 31) | def get_start_time(line_iterable, year):
  function extract_seconds (line 44) | def extract_seconds(input_file, output_file):

FILE: tools/extra/parse_log.py
  function parse_log (line 17) | def parse_log(path_to_log):
  function parse_line_for_net_output (line 77) | def parse_line_for_net_output(regex_obj, row, row_dict_list,
  function fix_initial_nan_learning_rate (line 119) | def fix_initial_nan_learning_rate(dict_list):
  function save_csv_files (line 132) | def save_csv_files(logfile_path, output_dir, train_dict_list, test_dict_...
  function write_csv (line 148) | def write_csv(output_filename, dict_list, delimiter, verbose=False):
  function parse_args (line 164) | def parse_args():
  function main (line 188) | def main():

FILE: tools/extra/resize_and_crop_images.py
  class OpenCVResizeCrop (line 19) | class OpenCVResizeCrop:
    method resize_and_crop_image (line 20) | def resize_and_crop_image(self, input_file, output_file, output_side_l...
  class PILResizeCrop (line 38) | class PILResizeCrop:
    method resize_and_crop_image (line 40) | def resize_and_crop_image(self, input_file, output_file, output_side_l...
  class ResizeCropImagesMapper (line 73) | class ResizeCropImagesMapper(mapreducer.BasicMapper):
    method map (line 77) | def map(self, key, value):

FILE: tools/extract_features.cpp
  function main (line 27) | int main(int argc, char** argv) {
  function feature_extraction_pipeline (line 33) | int feature_extraction_pipeline(int argc, char** argv) {

FILE: tools/finetune_net.cpp
  function main (line 3) | int main(int argc, char** argv) {

FILE: tools/net_speed_benchmark.cpp
  function main (line 3) | int main(int argc, char** argv) {

FILE: tools/test_net.cpp
  function main (line 3) | int main(int argc, char** argv) {

FILE: tools/train_net.cpp
  function main (line 3) | int main(int argc, char** argv) {

FILE: tools/upgrade_net_proto_binary.cpp
  function main (line 18) | int main(int argc, char** argv) {

FILE: tools/upgrade_net_proto_text.cpp
  function main (line 18) | int main(int argc, char** argv) {