File: toolresults_v1beta3firstparty.projects.histories.executions.html

package info (click to toggle)
python-googleapi 1.7.11-4
links: PTS
area: main
in suites: bullseye
size: 110,952 kB
sloc: python: 7,784; javascript: 249; makefile: 59; sh: 53; xml: 5
file content (1197 lines) | stat: -rw-r--r-- 85,576 bytes
parent folder | download | duplicates (2)
<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_v1beta3firstparty.html">Cloud Tool Results firstparty API</a> . <a href="toolresults_v1beta3firstparty.projects.html">projects</a> . <a href="toolresults_v1beta3firstparty.projects.histories.html">histories</a> . <a href="toolresults_v1beta3firstparty.projects.histories.executions.html">executions</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="toolresults_v1beta3firstparty.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 Histories for a given Project.</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 Test Service uses.
        # 
        # - In response: present if set by create - In create: optional - In update: never set
    "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
        #
        # # 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, though only UTC (as indicated by "Z") is presently supported.
        #
        # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
    },
    "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
    "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
    "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
        #
        # # 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, though only UTC (as indicated by "Z") is presently supported.
        #
        # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
        "crashed": True or False, # If the failure was severe because the system 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 Test Service uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
      },
      "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
      "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
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
          "crashed": True or False, # If the failure was severe because the system 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 Test Service uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
      },
      "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
      "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
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
          "crashed": True or False, # If the failure was severe because the system 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 Histories for a given Project.

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 Test Service uses.
              #
              # - In response: present if set by create - In create: optional - In update: never set
          "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
              #
              # # 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, though only UTC (as indicated by "Z") is presently supported.
              #
              # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
          },
          "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
          "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
          "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
              #
              # # 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, though only UTC (as indicated by "Z") is presently supported.
              #
              # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
              "crashed": True or False, # If the failure was severe because the system 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 Test Service uses.
        # 
        # - In response: present if set by create - In create: optional - In update: never set
    "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
        #
        # # 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, though only UTC (as indicated by "Z") is presently supported.
        #
        # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
    },
    "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
    "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
    "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
        #
        # # 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, though only UTC (as indicated by "Z") is presently supported.
        #
        # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
        "crashed": True or False, # If the failure was severe because the system 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 Test Service uses.
          #
          # - In response: present if set by create - In create: optional - In update: never set
      "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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.
      },
      "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
      "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
      "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. 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 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # 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
          #
          # # 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, though only UTC (as indicated by "Z") is presently supported.
          #
          # 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://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) 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": { # 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": { # 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": { # 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": { # 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 other than the app crashed.
          "crashed": True or False, # If the failure was severe because the system 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>