isage-middleware 0.1.4__py3-none-any.whl → 0.1.5.1__py3-none-any.whl

sage/middleware/components/sage_flow/build/_deps/fmt-src/support/python/mkdocstrings_handlers/cxx/__init__.py

@@ -0,0 +1,317 @@
+# A basic mkdocstrings handler for {fmt}.
+# Copyright (c) 2012 - present, Victor Zverovich
+
+import os
+from pathlib import Path
+from typing import Any, List, Mapping, Optional
+from subprocess import CalledProcessError, PIPE, Popen, STDOUT
+import xml.etree.ElementTree as et
+
+from mkdocstrings.handlers.base import BaseHandler
+
+class Definition:
+  '''A definition extracted by Doxygen.'''
+  def __init__(self, name: str, kind: Optional[str] = None,
+               node: Optional[et.Element] = None,
+               is_member: bool = False):
+    self.name = name
+    self.kind = kind if kind is not None else node.get('kind')
+    self.id = name if not is_member else None
+    self.params = None
+    self.members = None
+
+# A map from Doxygen to HTML tags.
+tag_map = {
+  'bold': 'b',
+  'emphasis': 'em',
+  'computeroutput': 'code',
+  'para': 'p',
+  'programlisting': 'pre',
+  'verbatim': 'pre'
+}
+
+# A map from Doxygen tags to text.
+tag_text_map = {
+  'codeline': '',
+  'highlight': '',
+  'sp': ' '
+}
+
+def escape_html(s: str) -> str:
+  return s.replace("<", "&lt;")
+
+def doxyxml2html(nodes: List[et.Element]):
+  out = ''
+  for n in nodes:
+    tag = tag_map.get(n.tag)
+    if not tag:
+      out += tag_text_map[n.tag]
+    out += '<' + tag + '>' if tag else ''
+    out += '<code class="language-cpp">' if tag == 'pre' else ''
+    if n.text:
+      out += escape_html(n.text)
+    out += doxyxml2html(n)
+    out += '</code>' if tag == 'pre' else ''
+    out += '</' + tag + '>' if tag else ''
+    if n.tail:
+      out += n.tail
+  return out
+
+def convert_template_params(node: et.Element) -> Optional[List[Definition]]:
+  templateparamlist = node.find('templateparamlist')
+  if templateparamlist is None:
+    return None
+  params = []
+  for param_node in templateparamlist.findall('param'):
+    name = param_node.find('declname')
+    param = Definition(name.text if name is not None else '', 'param')
+    param.type = param_node.find('type').text
+    params.append(param)
+  return params
+
+def get_description(node: et.Element) -> List[et.Element]:
+  return node.findall('briefdescription/para') + \
+         node.findall('detaileddescription/para')
+
+def normalize_type(type: str) -> str:
+  type = type.replace('< ', '<').replace(' >', '>')
+  return type.replace(' &', '&').replace(' *', '*')
+
+def convert_type(type: et.Element) -> str:
+  if type is None:
+    return None
+  result = type.text if type.text else ''
+  for ref in type:
+    result += ref.text
+    if ref.tail:
+      result += ref.tail
+  result += type.tail.strip()
+  return normalize_type(result)
+
+def convert_params(func: et.Element) -> Definition:
+  params = []
+  for p in func.findall('param'):
+    d = Definition(p.find('declname').text, 'param')
+    d.type = convert_type(p.find('type'))
+    params.append(d)
+  return params
+
+def convert_return_type(d: Definition, node: et.Element) -> None:
+  d.trailing_return_type = None
+  if d.type == 'auto' or d.type == 'constexpr auto':
+    parts = node.find('argsstring').text.split(' -> ')
+    if len(parts) > 1:
+      d.trailing_return_type = normalize_type(parts[1])
+
+def render_param(param: Definition) -> str:
+  return param.type + (f'&nbsp;{param.name}' if len(param.name) > 0 else '')
+
+def render_decl(d: Definition) -> None:
+  text = ''
+  if d.id is not None:
+    text += f'<a id="{d.id}">\n'
+  text += '<pre><code class="language-cpp decl">'
+
+  text += '<div>'
+  if d.template_params is not None:
+    text += 'template &lt;'
+    text += ', '.join([render_param(p) for p in d.template_params])
+    text += '&gt;\n'
+  text += '</div>'
+
+  text += '<div>'
+  end = ';'
+  if d.kind == 'function' or d.kind == 'variable':
+    text += d.type + ' ' if len(d.type) > 0 else ''
+  elif d.kind == 'typedef':
+    text += 'using '
+  elif d.kind == 'define':
+    end = ''
+  else:
+    text += d.kind + ' '
+  text += d.name
+
+  if d.params is not None:
+    params = ', '.join([
+      (p.type + ' ' if p.type else '') + p.name for p in d.params])
+    text += '(' + escape_html(params) + ')'
+    if d.trailing_return_type:
+      text += ' -&NoBreak;>&nbsp;' + escape_html(d.trailing_return_type)
+  elif d.kind == 'typedef':
+    text += ' = ' + escape_html(d.type)
+
+  text += end
+  text += '</div>'
+  text += '</code></pre>\n'
+  if d.id is not None:
+    text += f'</a>\n'
+  return text
+
+class CxxHandler(BaseHandler):
+  def __init__(self, **kwargs: Any) -> None:
+    super().__init__(handler='cxx', **kwargs)
+
+    headers = [
+      'args.h', 'base.h', 'chrono.h', 'color.h', 'compile.h', 'format.h',
+      'os.h', 'ostream.h', 'printf.h', 'ranges.h', 'std.h', 'xchar.h'
+    ]
+
+    # Run doxygen.
+    cmd = ['doxygen', '-']
+    support_dir = Path(__file__).parents[3]
+    top_dir = os.path.dirname(support_dir)
+    include_dir = os.path.join(top_dir, 'include', 'fmt')
+    self._ns2doxyxml = {}
+    build_dir = os.path.join(top_dir, 'build')
+    os.makedirs(build_dir, exist_ok=True)
+    self._doxyxml_dir = os.path.join(build_dir, 'doxyxml')
+    p = Popen(cmd, stdin=PIPE, stdout=PIPE, stderr=STDOUT)
+    _, _ = p.communicate(input=r'''
+        PROJECT_NAME      = fmt
+        GENERATE_XML      = YES
+        GENERATE_LATEX    = NO
+        GENERATE_HTML     = NO
+        INPUT             = {0}
+        XML_OUTPUT        = {1}
+        QUIET             = YES
+        AUTOLINK_SUPPORT  = NO
+        MACRO_EXPANSION   = YES
+        PREDEFINED        = _WIN32=1 \
+                            __linux__=1 \
+                            FMT_ENABLE_IF(...)= \
+                            FMT_USE_USER_DEFINED_LITERALS=1 \
+                            FMT_USE_ALIAS_TEMPLATES=1 \
+                            FMT_USE_NONTYPE_TEMPLATE_ARGS=1 \
+                            FMT_API= \
+                            "FMT_BEGIN_NAMESPACE=namespace fmt {{" \
+                            "FMT_END_NAMESPACE=}}" \
+                            "FMT_DOC=1"
+        '''.format(
+          ' '.join([os.path.join(include_dir, h) for h in headers]),
+          self._doxyxml_dir).encode('utf-8'))
+    if p.returncode != 0:
+      raise CalledProcessError(p.returncode, cmd)
+
+    # Merge all file-level XMLs into one to simplify search.
+    self._file_doxyxml = None
+    for h in headers:
+      filename = h.replace(".h", "_8h.xml")
+      with open(os.path.join(self._doxyxml_dir, filename)) as f:
+        doxyxml = et.parse(f)
+        if self._file_doxyxml is None:
+          self._file_doxyxml = doxyxml
+          continue
+        root = self._file_doxyxml.getroot()
+        for node in doxyxml.getroot():
+          root.append(node)
+
+  def collect_compound(self, identifier: str,
+                       cls: List[et.Element]) -> Definition:
+    '''Collect a compound definition such as a struct.'''
+    path = os.path.join(self._doxyxml_dir, cls[0].get('refid') + '.xml')
+    with open(path) as f:
+      xml = et.parse(f)
+      node = xml.find('compounddef')
+      d = Definition(identifier, node=node)
+      d.template_params = convert_template_params(node)
+      d.desc = get_description(node)
+      d.members = []
+      for m in node.findall('sectiondef[@kind="public-attrib"]/memberdef') + \
+               node.findall('sectiondef[@kind="public-func"]/memberdef'):
+        name = m.find('name').text
+        # Doxygen incorrectly classifies members of private unnamed unions as
+        # public members of the containing class.
+        if name.endswith('_'):
+          continue
+        desc = get_description(m)
+        if len(desc) == 0:
+          continue
+        kind = m.get('kind')
+        member = Definition(name if name else '', kind=kind, is_member=True)
+        type = m.find('type').text
+        member.type = type if type else ''
+        if kind == 'function':
+          member.params = convert_params(m)
+          convert_return_type(member, m)
+        member.template_params = None
+        member.desc = desc
+        d.members.append(member)
+      return d
+
+  def collect(self, identifier: str, config: Mapping[str, Any]) -> Definition:
+    qual_name = 'fmt::' + identifier
+
+    param_str = None
+    paren = qual_name.find('(')
+    if paren > 0:
+      qual_name, param_str = qual_name[:paren], qual_name[paren + 1:-1]
+    
+    colons = qual_name.rfind('::')
+    namespace, name = qual_name[:colons], qual_name[colons + 2:]
+
+    # Load XML.
+    doxyxml = self._ns2doxyxml.get(namespace)
+    if doxyxml is None:
+      path = f'namespace{namespace.replace("::", "_1_1")}.xml'
+      with open(os.path.join(self._doxyxml_dir, path)) as f:
+        doxyxml = et.parse(f)
+        self._ns2doxyxml[namespace] = doxyxml
+
+    nodes = doxyxml.findall(
+      f"compounddef/sectiondef/memberdef/name[.='{name}']/..")
+    if len(nodes) == 0:
+      nodes = self._file_doxyxml.findall(
+        f"compounddef/sectiondef/memberdef/name[.='{name}']/..")
+    candidates = []
+    for node in nodes:
+      # Process a function or a typedef.
+      params = None
+      d = Definition(name, node=node)
+      if d.kind == 'function':
+        params = convert_params(node)
+        node_param_str = ', '.join([p.type for p in params])
+        if param_str and param_str != node_param_str:
+          candidates.append(f'{name}({node_param_str})')
+          continue
+      elif d.kind == 'define':
+        params = []
+        for p in node.findall('param'):
+          param = Definition(p.find('defname').text, kind='param')
+          param.type = None
+          params.append(param)
+      d.type = convert_type(node.find('type'))
+      d.template_params = convert_template_params(node)
+      d.params = params
+      convert_return_type(d, node)
+      d.desc = get_description(node)
+      return d
+    
+    cls = doxyxml.findall(f"compounddef/innerclass[.='{qual_name}']")
+    if not cls:
+      raise Exception(f'Cannot find {identifier}. Candidates: {candidates}')
+    return self.collect_compound(identifier, cls)
+
+  def render(self, d: Definition, config: dict) -> str:
+    if d.id is not None:
+      self.do_heading('', 0, id=d.id)
+    text = '<div class="docblock">\n'
+    text += render_decl(d)
+    text += '<div class="docblock-desc">\n'
+    text += doxyxml2html(d.desc)
+    if d.members is not None:
+      for m in d.members:
+        text += self.render(m, config)
+    text += '</div>\n'
+    text += '</div>\n'
+    return text
+
+def get_handler(theme: str, custom_templates: Optional[str] = None,
+                **config: Any) -> CxxHandler:
+  '''Return an instance of `CxxHandler`.
+
+  Arguments:
+    theme: The theme to use when rendering contents.
+    custom_templates: Directory containing custom templates.
+    **config: Configuration passed to the handler.
+  '''
+  return CxxHandler(theme=theme, custom_templates=custom_templates)

sage/middleware/components/sage_flow/build/_deps/googletest-src/googlemock/test/gmock_leak_test.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python
+#
+# Copyright 2009, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""Tests that leaked mock objects can be caught be Google Mock."""
+
+from googlemock.test import gmock_test_utils
+
+PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_leak_test_')
+TEST_WITH_EXPECT_CALL = [PROGRAM_PATH, '--gtest_filter=*ExpectCall*']
+TEST_WITH_ON_CALL = [PROGRAM_PATH, '--gtest_filter=*OnCall*']
+TEST_MULTIPLE_LEAKS = [PROGRAM_PATH, '--gtest_filter=*MultipleLeaked*']
+
+environ = gmock_test_utils.environ
+SetEnvVar = gmock_test_utils.SetEnvVar
+
+# Tests in this file run a Google-Test-based test program and expect it
+# to terminate prematurely.  Therefore they are incompatible with
+# the premature-exit-file protocol by design.  Unset the
+# premature-exit filepath to prevent Google Test from creating
+# the file.
+SetEnvVar(gmock_test_utils.PREMATURE_EXIT_FILE_ENV_VAR, None)
+
+
+class GMockLeakTest(gmock_test_utils.TestCase):
+
+  def testCatchesLeakedMockByDefault(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_EXPECT_CALL, env=environ
+        ).exit_code,
+    )
+    self.assertNotEqual(
+        0, gmock_test_utils.Subprocess(TEST_WITH_ON_CALL, env=environ).exit_code
+    )
+
+  def testDoesNotCatchLeakedMockWhenDisabled(self):
+    self.assertEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_EXPECT_CALL + ['--gmock_catch_leaked_mocks=0'],
+            env=environ,
+        ).exit_code,
+    )
+    self.assertEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_ON_CALL + ['--gmock_catch_leaked_mocks=0'], env=environ
+        ).exit_code,
+    )
+
+  def testCatchesLeakedMockWhenEnabled(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_EXPECT_CALL + ['--gmock_catch_leaked_mocks'], env=environ
+        ).exit_code,
+    )
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_ON_CALL + ['--gmock_catch_leaked_mocks'], env=environ
+        ).exit_code,
+    )
+
+  def testCatchesLeakedMockWhenEnabledWithExplictFlagValue(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_WITH_EXPECT_CALL + ['--gmock_catch_leaked_mocks=1'],
+            env=environ,
+        ).exit_code,
+    )
+
+  def testCatchesMultipleLeakedMocks(self):
+    self.assertNotEqual(
+        0,
+        gmock_test_utils.Subprocess(
+            TEST_MULTIPLE_LEAKS + ['--gmock_catch_leaked_mocks'], env=environ
+        ).exit_code,
+    )
+
+
+if __name__ == '__main__':
+  gmock_test_utils.Main()

sage/middleware/components/sage_flow/build/_deps/googletest-src/googlemock/test/gmock_output_test.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+#
+# Copyright 2008, Google Inc.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above
+# copyright notice, this list of conditions and the following disclaimer
+# in the documentation and/or other materials provided with the
+# distribution.
+#     * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+r"""Tests the text output of Google C++ Mocking Framework.
+
+To update the golden file:
+gmock_output_test.py --build_dir=BUILD/DIR --gengolden
+where BUILD/DIR contains the built gmock_output_test_ file.
+gmock_output_test.py --gengolden
+gmock_output_test.py
+
+"""
+
+from io import open  # pylint: disable=redefined-builtin, g-importing-member
+import os
+import re
+import sys
+from googlemock.test import gmock_test_utils
+
+
+# The flag for generating the golden file
+GENGOLDEN_FLAG = '--gengolden'
+
+PROGRAM_PATH = gmock_test_utils.GetTestExecutablePath('gmock_output_test_')
+COMMAND = [PROGRAM_PATH, '--gtest_stack_trace_depth=0', '--gtest_print_time=0']
+GOLDEN_NAME = 'gmock_output_test_golden.txt'
+GOLDEN_PATH = os.path.join(gmock_test_utils.GetSourceDir(), GOLDEN_NAME)
+
+
+def ToUnixLineEnding(s):
+  """Changes all Windows/Mac line endings in s to UNIX line endings."""
+
+  return s.replace('\r\n', '\n').replace('\r', '\n')
+
+
+def RemoveReportHeaderAndFooter(output):
+  """Removes Google Test result report's header and footer from the output."""
+
+  output = re.sub(r'.*gtest_main.*\n', '', output)
+  output = re.sub(r'\[.*\d+ tests.*\n', '', output)
+  output = re.sub(r'\[.* test environment .*\n', '', output)
+  output = re.sub(r'\[=+\] \d+ tests .* ran.*', '', output)
+  output = re.sub(r'.* FAILED TESTS\n', '', output)
+  return output
+
+
+def RemoveLocations(output):
+  """Removes all file location info from a Google Test program's output.
+
+  Args:
+       output:  the output of a Google Test program.
+
+  Returns:
+       output with all file location info (in the form of
+       'DIRECTORY/FILE_NAME:LINE_NUMBER: 'or
+       'DIRECTORY\\FILE_NAME(LINE_NUMBER): ') replaced by
+       'FILE:#: '.
+  """
+
+  return re.sub(r'.*[/\\](.+)(\:\d+|\(\d+\))\:', 'FILE:#:', output)
+
+
+def NormalizeErrorMarker(output):
+  """Normalizes the error marker, which is different on Windows vs on Linux."""
+
+  return re.sub(r' error: ', ' Failure\n', output)
+
+
+def RemoveMemoryAddresses(output):
+  """Removes memory addresses from the test output."""
+
+  return re.sub(r'@\w+', '@0x#', output)
+
+
+def RemoveTestNamesOfLeakedMocks(output):
+  """Removes the test names of leaked mock objects from the test output."""
+
+  return re.sub(r'\(used in test .+\) ', '', output)
+
+
+def GetLeakyTests(output):
+  """Returns a list of test names that leak mock objects."""
+
+  # findall() returns a list of all matches of the regex in output.
+  # For example, if '(used in test FooTest.Bar)' is in output, the
+  # list will contain 'FooTest.Bar'.
+  return re.findall(r'\(used in test (.+)\)', output)
+
+
+def GetNormalizedOutputAndLeakyTests(output):
+  """Normalizes the output of gmock_output_test_.
+
+  Args:
+    output: The test output.
+
+  Returns:
+    A tuple (the normalized test output, the list of test names that have
+    leaked mocks).
+  """
+
+  output = ToUnixLineEnding(output)
+  output = RemoveReportHeaderAndFooter(output)
+  output = NormalizeErrorMarker(output)
+  output = RemoveLocations(output)
+  output = RemoveMemoryAddresses(output)
+  return (RemoveTestNamesOfLeakedMocks(output), GetLeakyTests(output))
+
+
+def GetShellCommandOutput(cmd):
+  """Runs a command in a sub-process, and returns its STDOUT in a string."""
+
+  return gmock_test_utils.Subprocess(cmd, capture_stderr=False).output
+
+
+def GetNormalizedCommandOutputAndLeakyTests(cmd):
+  """Runs a command and returns its normalized output and a list of leaky tests.
+
+  Args:
+    cmd:  the shell command.
+  """
+
+  # Disables exception pop-ups on Windows.
+  os.environ['GTEST_CATCH_EXCEPTIONS'] = '1'
+  return GetNormalizedOutputAndLeakyTests(GetShellCommandOutput(cmd))
+
+
+class GMockOutputTest(gmock_test_utils.TestCase):
+
+  def testOutput(self):
+    (output, leaky_tests) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
+    golden_file = open(GOLDEN_PATH, 'rb')
+    golden = golden_file.read().decode('utf-8')
+    golden_file.close()
+    # On Windows the repository might have been checked out with \r\n line
+    # endings, so normalize it here.
+    golden = ToUnixLineEnding(golden)
+
+    # The normalized output should match the golden file.
+    self.assertEqual(golden, output)
+
+    # The raw output should contain 2 leaked mock object errors for
+    # test GMockOutputTest.CatchesLeakedMocks.
+    self.assertEqual(
+        [
+            'GMockOutputTest.CatchesLeakedMocks',
+            'GMockOutputTest.CatchesLeakedMocks',
+        ],
+        leaky_tests,
+    )
+
+
+if __name__ == '__main__':
+  if sys.argv[1:] == [GENGOLDEN_FLAG]:
+    (output, _) = GetNormalizedCommandOutputAndLeakyTests(COMMAND)
+    golden_file = open(GOLDEN_PATH, 'wb')
+    golden_file.write(output)
+    golden_file.close()
+    # Suppress the error "googletest was imported but a call to its main()
+    # was never detected."
+    os._exit(0)
+  else:
+    gmock_test_utils.Main()