<html><body>
<style>

body, h1, h2, h3, div, span, p, pre, a {
  margin: 0;
  padding: 0;
  border: 0;
  font-weight: inherit;
  font-style: inherit;
  font-size: 100%;
  font-family: inherit;
  vertical-align: baseline;
}

body {
  font-size: 13px;
  padding: 1em;
}

h1 {
  font-size: 26px;
  margin-bottom: 1em;
}

h2 {
  font-size: 24px;
  margin-bottom: 1em;
}

h3 {
  font-size: 20px;
  margin-bottom: 1em;
  margin-top: 1em;
}

pre, code {
  line-height: 1.5;
  font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
}

pre {
  margin-top: 0.5em;
}

h1, h2, h3, p {
  font-family: Arial, sans serif;
}

h1, h2, h3 {
  border-bottom: solid #CCC 1px;
}

.toc_element {
  margin-top: 0.5em;
}

.firstline {
  margin-left: 2 em;
}

.method  {
  margin-top: 1em;
  border: solid 1px #CCC;
  padding: 1em;
  background: #EEE;
}

.details {
  font-weight: bold;
  font-size: 14px;
}

</style>

<h1><a href="toolresults_v1beta3.html">Cloud Tool Results API</a> . <a href="toolresults_v1beta3.projects.html">projects</a> . <a href="toolresults_v1beta3.projects.histories.html">histories</a> . <a href="toolresults_v1beta3.projects.histories.executions.html">executions</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="toolresults_v1beta3.projects.histories.executions.clusters.html">clusters()</a></code>
</p>
<p class="firstline">Returns the clusters Resource.</p>

<p class="toc_element">
  <code><a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps()</a></code>
</p>
<p class="firstline">Returns the steps Resource.</p>

<p class="toc_element">
  <code><a href="#create">create(projectId, historyId, body, requestId=None)</a></code></p>
<p class="firstline">Creates an Execution.</p>
<p class="toc_element">
  <code><a href="#get">get(projectId, historyId, executionId)</a></code></p>
<p class="firstline">Gets an Execution.</p>
<p class="toc_element">
  <code><a href="#list">list(projectId, historyId, pageToken=None, pageSize=None)</a></code></p>
<p class="firstline">Lists Executions for a given History.</p>
<p class="toc_element">
  <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
<p class="firstline">Retrieves the next page of results.</p>
<p class="toc_element">
  <code><a href="#patch">patch(projectId, historyId, executionId, body, requestId=None)</a></code></p>
<p class="firstline">Updates an existing Execution with the supplied partial entity.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="create">create(projectId, historyId, body, requestId=None)</code>
  <pre>Creates an Execution.

The returned Execution will have the id set.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the containing History does not exist

Args:
  projectId: string, A Project id.

Required. (required)
  historyId: string, A History id.

Required. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
      # 
      # The maximum size of an execution message is 1 MiB.
      # 
      # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
    "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
        # 
        # - In response: present if set by create - In create: optional - In update: never set
    "specification": { # The details about how to run the execution. # Lightweight information about execution request.
        # 
        # - In response: present if set by create - In create: optional - In update: optional
      "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
        "androidAppInfo": { # Android app information. # Information about the application under test.
          "versionCode": "A String", # The internal version code of the app. Optional.
          "packageName": "A String", # The package name of the app. Required.
          "name": "A String", # The name of the app. Optional
          "versionName": "A String", # The version name of the app. Optional.
        },
        "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
          "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
          "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
          "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
          "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
          "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
        },
        "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
            #
            # # Examples
            #
            # Example 1: Compute Duration from two Timestamps in pseudo code.
            #
            # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
            #
            # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
            #
            # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
            #
            # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
            #
            # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
            #
            # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
            #
            # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
            #
            # Example 3: Compute Duration from datetime.timedelta in Python.
            #
            # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
            #
            # # JSON Mapping
            #
            # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
          "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
          "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        },
        "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
            #
            # See  for more information on types of Android tests.
          "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
          "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
          "testPackageId": "A String", # The java package for the test to be executed. Required
          "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
              #
              # If empty, all targets in the module will be run.
            "A String",
          ],
        },
      },
    },
    "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
        # 
        # This value will be set automatically when CreateExecution is called.
        # 
        # - In response: always set - In create/update request: never set
        #
        # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
        #
        # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
        #
        # # Examples
        #
        # Example 1: Compute Timestamp from POSIX `time()`.
        #
        # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
        #
        # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
        #
        # struct timeval tv; gettimeofday(&tv, NULL);
        #
        # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
        #
        # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
        #
        # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
        #
        # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
        #
        # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
        #
        # long millis = System.currentTimeMillis();
        #
        # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
        #
        #
        #
        # Example 5: Compute Timestamp from current time in Python.
        #
        # timestamp = Timestamp() timestamp.GetCurrentTime()
        #
        # # JSON Mapping
        #
        # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
        #
        # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
        #
        # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
      "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
      "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
    },
    "executionId": "A String", # A unique identifier within a History for this Execution.
        # 
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        # 
        # - In response always set - In create/update request: never set
    "state": "A String", # The initial state is IN_PROGRESS.
        # 
        # The only legal state transitions is from IN_PROGRESS to COMPLETE.
        # 
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        # 
        # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
        # 
        # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
        # 
        # - In response always set - In create/update request: optional
    "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
        # 
        # This value will be set automatically when state transitions to COMPLETE.
        # 
        # - In response: set if the execution state is COMPLETE. - In create/update request: never set
        #
        # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
        #
        # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
        #
        # # Examples
        #
        # Example 1: Compute Timestamp from POSIX `time()`.
        #
        # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
        #
        # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
        #
        # struct timeval tv; gettimeofday(&tv, NULL);
        #
        # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
        #
        # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
        #
        # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
        #
        # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
        #
        # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
        #
        # long millis = System.currentTimeMillis();
        #
        # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
        #
        #
        #
        # Example 5: Compute Timestamp from current time in Python.
        #
        # timestamp = Timestamp() timestamp.GetCurrentTime()
        #
        # # JSON Mapping
        #
        # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
        #
        # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
        #
        # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
      "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
      "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
    },
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
        # 
        # - In response: present if set by create/update request - In create/update request: optional
      "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
          #
          # Optional
        "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
            #
            # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
        "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
      },
      "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
          #
          # Optional
        "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
        "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
        "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
      },
      "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
          #
          # Optional
        "otherNativeCrash": True or False, # If a native process other than the app crashed.
      },
      "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
          #
          # Optional
        "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
        "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
        "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
        "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
        "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
      },
      "summary": "A String", # The simplest way to interpret a result.
          #
          # Required
    },
  }

  requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID.

Optional, but strongly recommended.

Returns:
  An object of the form:

    { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
        #
        # The maximum size of an execution message is 1 MiB.
        #
        # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
      "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "specification": { # The details about how to run the execution. # Lightweight information about execution request.
          #
          # - In response: present if set by create - In create: optional - In update: optional
        "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
          "androidAppInfo": { # Android app information. # Information about the application under test.
            "versionCode": "A String", # The internal version code of the app. Optional.
            "packageName": "A String", # The package name of the app. Required.
            "name": "A String", # The name of the app. Optional
            "versionName": "A String", # The version name of the app. Optional.
          },
          "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
            "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
            "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
            "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
            "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
            "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
          },
          "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
              #
              # # Examples
              #
              # Example 1: Compute Duration from two Timestamps in pseudo code.
              #
              # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
              #
              # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
              #
              # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
              #
              # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
              #
              # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
              #
              # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
              #
              # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
              #
              # Example 3: Compute Duration from datetime.timedelta in Python.
              #
              # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
              #
              # # JSON Mapping
              #
              # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
            "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
            "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
          },
          "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
              #
              # See  for more information on types of Android tests.
            "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
            "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
            "testPackageId": "A String", # The java package for the test to be executed. Required
            "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
                #
                # If empty, all targets in the module will be run.
              "A String",
            ],
          },
        },
      },
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
          #
          # This value will be set automatically when CreateExecution is called.
          #
          # - In response: always set - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "executionId": "A String", # A unique identifier within a History for this Execution.
          #
          # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
          #
          # - In response always set - In create/update request: never set
      "state": "A String", # The initial state is IN_PROGRESS.
          #
          # The only legal state transitions is from IN_PROGRESS to COMPLETE.
          #
          # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
          #
          # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
          #
          # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
          #
          # - In response always set - In create/update request: optional
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
          #
          # This value will be set automatically when state transitions to COMPLETE.
          #
          # - In response: set if the execution state is COMPLETE. - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
            #
            # Optional
          "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
              #
              # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
          "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
        },
        "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
            #
            # Optional
          "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
          "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
          "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
        },
        "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process other than the app crashed.
        },
        "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
          "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
          "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
          "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
          "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
        },
        "summary": "A String", # The simplest way to interpret a result.
            #
            # Required
      },
    }</pre>
</div>

<div class="method">
    <code class="details" id="get">get(projectId, historyId, executionId)</code>
  <pre>Gets an Execution.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the Execution does not exist

Args:
  projectId: string, A Project id.

Required. (required)
  historyId: string, A History id.

Required. (required)
  executionId: string, An Execution id.

Required. (required)

Returns:
  An object of the form:

    { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
        #
        # The maximum size of an execution message is 1 MiB.
        #
        # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
      "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "specification": { # The details about how to run the execution. # Lightweight information about execution request.
          #
          # - In response: present if set by create - In create: optional - In update: optional
        "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
          "androidAppInfo": { # Android app information. # Information about the application under test.
            "versionCode": "A String", # The internal version code of the app. Optional.
            "packageName": "A String", # The package name of the app. Required.
            "name": "A String", # The name of the app. Optional
            "versionName": "A String", # The version name of the app. Optional.
          },
          "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
            "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
            "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
            "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
            "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
            "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
          },
          "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
              #
              # # Examples
              #
              # Example 1: Compute Duration from two Timestamps in pseudo code.
              #
              # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
              #
              # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
              #
              # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
              #
              # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
              #
              # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
              #
              # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
              #
              # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
              #
              # Example 3: Compute Duration from datetime.timedelta in Python.
              #
              # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
              #
              # # JSON Mapping
              #
              # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
            "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
            "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
          },
          "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
              #
              # See  for more information on types of Android tests.
            "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
            "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
            "testPackageId": "A String", # The java package for the test to be executed. Required
            "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
                #
                # If empty, all targets in the module will be run.
              "A String",
            ],
          },
        },
      },
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
          #
          # This value will be set automatically when CreateExecution is called.
          #
          # - In response: always set - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "executionId": "A String", # A unique identifier within a History for this Execution.
          #
          # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
          #
          # - In response always set - In create/update request: never set
      "state": "A String", # The initial state is IN_PROGRESS.
          #
          # The only legal state transitions is from IN_PROGRESS to COMPLETE.
          #
          # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
          #
          # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
          #
          # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
          #
          # - In response always set - In create/update request: optional
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
          #
          # This value will be set automatically when state transitions to COMPLETE.
          #
          # - In response: set if the execution state is COMPLETE. - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
            #
            # Optional
          "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
              #
              # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
          "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
        },
        "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
            #
            # Optional
          "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
          "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
          "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
        },
        "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process other than the app crashed.
        },
        "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
          "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
          "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
          "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
          "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
        },
        "summary": "A String", # The simplest way to interpret a result.
            #
            # Required
      },
    }</pre>
</div>

<div class="method">
    <code class="details" id="list">list(projectId, historyId, pageToken=None, pageSize=None)</code>
  <pre>Lists Executions for a given History.

The executions are sorted by creation_time in descending order. The execution_id key will be used to order the executions with the same creation_time.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the containing History does not exist

Args:
  projectId: string, A Project id.

Required. (required)
  historyId: string, A History id.

Required. (required)
  pageToken: string, A continuation token to resume the query at the next item.

Optional.
  pageSize: integer, The maximum number of Executions to fetch.

Default value: 25. The server will use this default if the field is not set or has a value of 0.

Optional.

Returns:
  An object of the form:

    {
    "nextPageToken": "A String", # A continuation token to resume the query at the next item.
        #
        # Will only be set if there are more Executions to fetch.
    "executions": [ # Executions.
        #
        # Always set.
      { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
            #
            # The maximum size of an execution message is 1 MiB.
            #
            # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
          "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
              #
              # - In response: present if set by create - In create: optional - In update: never set
          "specification": { # The details about how to run the execution. # Lightweight information about execution request.
              #
              # - In response: present if set by create - In create: optional - In update: optional
            "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
              "androidAppInfo": { # Android app information. # Information about the application under test.
                "versionCode": "A String", # The internal version code of the app. Optional.
                "packageName": "A String", # The package name of the app. Required.
                "name": "A String", # The name of the app. Optional
                "versionName": "A String", # The version name of the app. Optional.
              },
              "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
                "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
                "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
                "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
                "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
                "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
              },
              "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
                  #
                  # # Examples
                  #
                  # Example 1: Compute Duration from two Timestamps in pseudo code.
                  #
                  # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
                  #
                  # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
                  #
                  # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
                  #
                  # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
                  #
                  # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
                  #
                  # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
                  #
                  # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
                  #
                  # Example 3: Compute Duration from datetime.timedelta in Python.
                  #
                  # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
                  #
                  # # JSON Mapping
                  #
                  # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
                "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
                "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
              },
              "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
                  #
                  # See  for more information on types of Android tests.
                "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
                "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
                "testPackageId": "A String", # The java package for the test to be executed. Required
                "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
                    #
                    # If empty, all targets in the module will be run.
                  "A String",
                ],
              },
            },
          },
          "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
              #
              # This value will be set automatically when CreateExecution is called.
              #
              # - In response: always set - In create/update request: never set
              #
              # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
              #
              # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
              #
              # # Examples
              #
              # Example 1: Compute Timestamp from POSIX `time()`.
              #
              # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
              #
              # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
              #
              # struct timeval tv; gettimeofday(&tv, NULL);
              #
              # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
              #
              # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
              #
              # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
              #
              # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
              #
              # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
              #
              # long millis = System.currentTimeMillis();
              #
              # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
              #
              #
              #
              # Example 5: Compute Timestamp from current time in Python.
              #
              # timestamp = Timestamp() timestamp.GetCurrentTime()
              #
              # # JSON Mapping
              #
              # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
              #
              # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
              #
              # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
            "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
            "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
          },
          "executionId": "A String", # A unique identifier within a History for this Execution.
              #
              # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
              #
              # - In response always set - In create/update request: never set
          "state": "A String", # The initial state is IN_PROGRESS.
              #
              # The only legal state transitions is from IN_PROGRESS to COMPLETE.
              #
              # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
              #
              # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
              #
              # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
              #
              # - In response always set - In create/update request: optional
          "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
              #
              # This value will be set automatically when state transitions to COMPLETE.
              #
              # - In response: set if the execution state is COMPLETE. - In create/update request: never set
              #
              # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
              #
              # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
              #
              # # Examples
              #
              # Example 1: Compute Timestamp from POSIX `time()`.
              #
              # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
              #
              # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
              #
              # struct timeval tv; gettimeofday(&tv, NULL);
              #
              # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
              #
              # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
              #
              # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
              #
              # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
              #
              # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
              #
              # long millis = System.currentTimeMillis();
              #
              # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
              #
              #
              #
              # Example 5: Compute Timestamp from current time in Python.
              #
              # timestamp = Timestamp() timestamp.GetCurrentTime()
              #
              # # JSON Mapping
              #
              # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
              #
              # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
              #
              # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
            "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
            "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
          },
          "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
              #
              # - In response: present if set by create/update request - In create/update request: optional
            "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
                #
                # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
                #
                # Optional
              "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
                  #
                  # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
              "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
            },
            "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
                #
                # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
                #
                # Optional
              "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
              "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
              "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
            },
            "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
                #
                # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
                #
                # Optional
              "otherNativeCrash": True or False, # If a native process other than the app crashed.
            },
            "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
                #
                # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
                #
                # Optional
              "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
              "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
              "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
              "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
              "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
            },
            "summary": "A String", # The simplest way to interpret a result.
                #
                # Required
          },
        },
    ],
  }</pre>
</div>

<div class="method">
    <code class="details" id="list_next">list_next(previous_request, previous_response)</code>
  <pre>Retrieves the next page of results.

Args:
  previous_request: The request for the previous page. (required)
  previous_response: The response from the request for the previous page. (required)

Returns:
  A request object that you can call 'execute()' on to request the next
  page. Returns None if there are no more items in the collection.
    </pre>
</div>

<div class="method">
    <code class="details" id="patch">patch(projectId, historyId, executionId, body, requestId=None)</code>
  <pre>Updates an existing Execution with the supplied partial entity.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal - NOT_FOUND - if the containing History does not exist

Args:
  projectId: string, A Project id. Required. (required)
  historyId: string, Required. (required)
  executionId: string, Required. (required)
  body: object, The request body. (required)
    The object takes the form of:

{ # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
      # 
      # The maximum size of an execution message is 1 MiB.
      # 
      # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
    "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
        # 
        # - In response: present if set by create - In create: optional - In update: never set
    "specification": { # The details about how to run the execution. # Lightweight information about execution request.
        # 
        # - In response: present if set by create - In create: optional - In update: optional
      "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
        "androidAppInfo": { # Android app information. # Information about the application under test.
          "versionCode": "A String", # The internal version code of the app. Optional.
          "packageName": "A String", # The package name of the app. Required.
          "name": "A String", # The name of the app. Optional
          "versionName": "A String", # The version name of the app. Optional.
        },
        "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
          "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
          "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
          "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
          "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
          "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
        },
        "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
            #
            # # Examples
            #
            # Example 1: Compute Duration from two Timestamps in pseudo code.
            #
            # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
            #
            # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
            #
            # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
            #
            # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
            #
            # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
            #
            # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
            #
            # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
            #
            # Example 3: Compute Duration from datetime.timedelta in Python.
            #
            # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
            #
            # # JSON Mapping
            #
            # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
          "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
          "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
        },
        "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
            #
            # See  for more information on types of Android tests.
          "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
          "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
          "testPackageId": "A String", # The java package for the test to be executed. Required
          "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
              #
              # If empty, all targets in the module will be run.
            "A String",
          ],
        },
      },
    },
    "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
        # 
        # This value will be set automatically when CreateExecution is called.
        # 
        # - In response: always set - In create/update request: never set
        #
        # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
        #
        # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
        #
        # # Examples
        #
        # Example 1: Compute Timestamp from POSIX `time()`.
        #
        # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
        #
        # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
        #
        # struct timeval tv; gettimeofday(&tv, NULL);
        #
        # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
        #
        # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
        #
        # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
        #
        # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
        #
        # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
        #
        # long millis = System.currentTimeMillis();
        #
        # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
        #
        #
        #
        # Example 5: Compute Timestamp from current time in Python.
        #
        # timestamp = Timestamp() timestamp.GetCurrentTime()
        #
        # # JSON Mapping
        #
        # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
        #
        # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
        #
        # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
      "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
      "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
    },
    "executionId": "A String", # A unique identifier within a History for this Execution.
        # 
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        # 
        # - In response always set - In create/update request: never set
    "state": "A String", # The initial state is IN_PROGRESS.
        # 
        # The only legal state transitions is from IN_PROGRESS to COMPLETE.
        # 
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        # 
        # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
        # 
        # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
        # 
        # - In response always set - In create/update request: optional
    "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
        # 
        # This value will be set automatically when state transitions to COMPLETE.
        # 
        # - In response: set if the execution state is COMPLETE. - In create/update request: never set
        #
        # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
        #
        # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
        #
        # # Examples
        #
        # Example 1: Compute Timestamp from POSIX `time()`.
        #
        # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
        #
        # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
        #
        # struct timeval tv; gettimeofday(&tv, NULL);
        #
        # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
        #
        # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
        #
        # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
        #
        # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
        #
        # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
        #
        # long millis = System.currentTimeMillis();
        #
        # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
        #
        #
        #
        # Example 5: Compute Timestamp from current time in Python.
        #
        # timestamp = Timestamp() timestamp.GetCurrentTime()
        #
        # # JSON Mapping
        #
        # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
        #
        # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
        #
        # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
      "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
      "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
    },
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
        # 
        # - In response: present if set by create/update request - In create/update request: optional
      "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
          #
          # Optional
        "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
            #
            # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
        "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
      },
      "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
          #
          # Optional
        "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
        "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
        "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
      },
      "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
          #
          # Optional
        "otherNativeCrash": True or False, # If a native process other than the app crashed.
      },
      "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
          #
          # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
          #
          # Optional
        "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
        "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
        "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
        "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
        "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
      },
      "summary": "A String", # The simplest way to interpret a result.
          #
          # Required
    },
  }

  requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID.

Optional, but strongly recommended.

Returns:
  An object of the form:

    { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step
        #
        # The maximum size of an execution message is 1 MiB.
        #
        # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable.
      "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "specification": { # The details about how to run the execution. # Lightweight information about execution request.
          #
          # - In response: present if set by create - In create: optional - In update: optional
        "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification.
          "androidAppInfo": { # Android app information. # Information about the application under test.
            "versionCode": "A String", # The internal version code of the app. Optional.
            "packageName": "A String", # The package name of the app. Required.
            "name": "A String", # The name of the app. Optional
            "versionName": "A String", # The version name of the app. Optional.
          },
          "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test.
            "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional
            "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional
            "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional
            "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional
            "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional
          },
          "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled.
              #
              # # Examples
              #
              # Example 1: Compute Duration from two Timestamps in pseudo code.
              #
              # Timestamp start = ...; Timestamp end = ...; Duration duration = ...;
              #
              # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos;
              #
              # if (duration.seconds  0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; }
              #
              # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
              #
              # Timestamp start = ...; Duration duration = ...; Timestamp end = ...;
              #
              # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos;
              #
              # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; }
              #
              # Example 3: Compute Duration from datetime.timedelta in Python.
              #
              # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td)
              #
              # # JSON Mapping
              #
              # In JSON format, the Duration type is encoded as a string rather than an object, where the string ends in the suffix "s" (indicating seconds) and is preceded by the number of seconds, with nanoseconds expressed as fractional seconds. For example, 3 seconds with 0 nanoseconds should be encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should be expressed in JSON format as "3.000000001s", and 3 seconds and 1 microsecond should be expressed in JSON format as "3.000001s".
            "nanos": 42, # Signed fractions of a second at nanosecond resolution of the span of time. Durations less than one second are represented with a 0 `seconds` field and a positive or negative `nanos` field. For durations of one second or more, a non-zero value for the `nanos` field must be of the same sign as the `seconds` field. Must be from -999,999,999 to +999,999,999 inclusive.
            "seconds": "A String", # Signed seconds of the span of time. Must be from -315,576,000,000 to +315,576,000,000 inclusive. Note: these bounds are computed from: 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
          },
          "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test.
              #
              # See  for more information on types of Android tests.
            "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not.
            "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required
            "testPackageId": "A String", # The java package for the test to be executed. Required
            "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name"
                #
                # If empty, all targets in the module will be run.
              "A String",
            ],
          },
        },
      },
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created.
          #
          # This value will be set automatically when CreateExecution is called.
          #
          # - In response: always set - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "executionId": "A String", # A unique identifier within a History for this Execution.
          #
          # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
          #
          # - In response always set - In create/update request: never set
      "state": "A String", # The initial state is IN_PROGRESS.
          #
          # The only legal state transitions is from IN_PROGRESS to COMPLETE.
          #
          # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
          #
          # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times.
          #
          # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE.
          #
          # - In response always set - In create/update request: optional
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE.
          #
          # This value will be set automatically when state transitions to COMPLETE.
          #
          # - In response: set if the execution state is COMPLETE. - In create/update request: never set
          #
          # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear).
          #
          # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
          #
          # # Examples
          #
          # Example 1: Compute Timestamp from POSIX `time()`.
          #
          # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0);
          #
          # Example 2: Compute Timestamp from POSIX `gettimeofday()`.
          #
          # struct timeval tv; gettimeofday(&tv, NULL);
          #
          # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000);
          #
          # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
          #
          # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
          #
          # // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. Timestamp timestamp; timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
          #
          # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
          #
          # long millis = System.currentTimeMillis();
          #
          # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build();
          #
          #
          #
          # Example 5: Compute Timestamp from current time in Python.
          #
          # timestamp = Timestamp() timestamp.GetCurrentTime()
          #
          # # JSON Mapping
          #
          # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset).
          #
          # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017.
          #
          # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format.
        "nanos": 42, # Non-negative fractions of a second at nanosecond resolution. Negative second values with fractions must still have non-negative nanos values that count forward in time. Must be from 0 to 999,999,999 inclusive.
        "seconds": "A String", # Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z inclusive.
      },
      "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE.
            #
            # Optional
          "infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed.
              #
              # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
          "abortedByUser": True or False, # If the end user aborted the test execution before a pass or fail could be determined. For example, the user pressed ctrl-c which sent a kill signal to the test runner while the test was running.
        },
        "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED.
            #
            # Optional
          "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
          "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
          "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
        },
        "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process other than the app crashed.
        },
        "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome.
            #
            # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE.
            #
            # Optional
          "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
          "crashed": True or False, # If the failure was severe because the system (app) under test crashed.
          "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
          "notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
          "timedOut": True or False, # If the test overran some time limit, and that is why it failed.
        },
        "summary": "A String", # The simplest way to interpret a result.
            #
            # Required
      },
    }</pre>
</div>

</body></html>