toolresults_v1beta3firstparty.projects.histories.executions.steps.html - Android社区

<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> . <a href="toolresults_v1beta3firstparty.projects.histories.executions.steps.html">steps</a></h1>
<h2>Instance Methods</h2>
<p class="toc_element">
  <code><a href="toolresults_v1beta3firstparty.projects.histories.executions.steps.perfMetricsSummary.html">perfMetricsSummary()</a></code>
</p>
<p class="firstline">Returns the perfMetricsSummary Resource.</p>

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

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

<p class="toc_element">
  <code><a href="#create">create(projectId, historyId, executionId, body, requestId=None)</a></code></p>
<p class="firstline">Creates a Step.</p>
<p class="toc_element">
  <code><a href="#get">get(projectId, historyId, executionId, stepId)</a></code></p>
<p class="firstline">Gets a Step.</p>
<p class="toc_element">
  <code><a href="#getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId)</a></code></p>
<p class="firstline">Retrieves a PerfMetricsSummary.</p>
<p class="toc_element">
  <code><a href="#list">list(projectId, historyId, executionId, pageToken=None, pageSize=None)</a></code></p>
<p class="firstline">Lists Steps for a given Execution.</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, stepId, body, requestId=None)</a></code></p>
<p class="firstline">Updates an existing Step with the supplied partial entity.</p>
<p class="toc_element">
  <code><a href="#publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body)</a></code></p>
<p class="firstline">Publish xml files to an existing Step.</p>
<h3>Method Details</h3>
<div class="method">
    <code class="details" id="create">create(projectId, historyId, executionId, body, requestId=None)</code>
  <pre>Creates a Step.

The returned Step 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 - FAILED_PRECONDITION - if the step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist

Args:
  projectId: string, A Project id.

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

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

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

{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
    # 
    # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
    # 
    # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
    # 
    # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
  "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
      #
      # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
      #
      # Users can also add test results manually by using the test_result field.
    "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
        #
        # - In response: present if set by create or update - In create/update request: optional
      "testProcessDuration": { # 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. # How long it took to run the test process.
          #
          # - In response: present if previously set. - In create/update request: optional
          #
          # # 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
      },
    },
    "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
        #
        # The maximum allowed number of test suite overviews per step is 1000.
        #
        # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
      { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
          #
          # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
        "name": "A String", # The name of the test suite.
            #
            # - In create/response: always set - In update request: never
        "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
        "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
        "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
            #
            # Note: Multiple test suites can share the same xml_source
            #
            # Returns INVALID_ARGUMENT if the uri format is not supported.
            #
            # - In create/response: optional - In update request: never
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
        "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
            #
            # - In create/response: always set - In update request: never
        "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
      },
    ],
    "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
        #
        # The exit code of this tool will be used to determine if the test passed.
        #
        # - In response: always set - In create/update request: optional
      "toolLogs": [ # References to any plain text logs output the tool execution.
          #
          # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
          #
          # The maximum allowed number of tool logs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a file.
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
      ],
      "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
        "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
            #
            # - In response: always set - In create/update request: always set
      },
      "toolOutputs": [ # References to opaque files of any format output by the tool execution.
          #
          # The maximum allowed number of tool outputs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a ToolExecution output file.
          "testCase": { # A reference to a test case. # The test case to which this output file belongs.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
            "className": "A String", # The name of the class.
            "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
            "name": "A String", # The name of the test case.
                #
                # Required.
          },
          "output": { # A reference to a file. # A FileReference to an output file.
              #
              # - In response: always set - In create/update request: always set
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always 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 creation time of the file.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # # 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.
          },
        },
      ],
      "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
          #
          # - In response: present if set by create request - In create request: optional - In update request: never set
        "A String",
      ],
    },
    "testIssues": [ # Issues observed during the test execution.
        #
        # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
        #
        # - In response: present if set by create or update - In create/update request: optional
      { # An abnormal event observed during the test execution.
        "stackTrace": { # A stacktrace. # Optional.
          "exception": "A String", # The stack trace message.
              #
              # Required
        },
        "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
            #
            # Required.
      },
    ],
  },
  "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
    "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
        #
        # - In response: present if set by create/update request - In create/update request: optional
      "toolLogs": [ # References to any plain text logs output the tool execution.
          #
          # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
          #
          # The maximum allowed number of tool logs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a file.
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
      ],
      "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
        "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
            #
            # - In response: always set - In create/update request: always set
      },
      "toolOutputs": [ # References to opaque files of any format output by the tool execution.
          #
          # The maximum allowed number of tool outputs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a ToolExecution output file.
          "testCase": { # A reference to a test case. # The test case to which this output file belongs.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
            "className": "A String", # The name of the class.
            "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
            "name": "A String", # The name of the test case.
                #
                # Required.
          },
          "output": { # A reference to a file. # A FileReference to an output file.
              #
              # - In response: always set - In create/update request: always set
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always 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 creation time of the file.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # # 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.
          },
        },
      ],
      "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
          #
          # - In response: present if set by create request - In create request: optional - In update request: never set
        "A String",
      ],
    },
  },
  "stepId": "A String", # A unique identifier within a Execution for this Step.
      # 
      # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
      # 
      # - In response: always set - In create/update request: never set
  "runDuration": { # 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. # How long it took for this step to run.
      # 
      # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
      # 
      # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
      # 
      # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
      #
      # # 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
  },
  "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
      # 
      # - In response: present if set by create/update request - In create/update request: optional
  "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
      # 
      # Users are responsible for managing the key namespace such that keys don't accidentally collide.
      # 
      # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
      # 
      # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
    {
      "value": "A String",
      "key": "A String",
    },
  ],
  "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 step was created.
      # 
      # - 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.
  },
  "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
      # 
      # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
      # 
      # - In response: always set - In create request: always set - In update request: never set
  "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
      # 
      # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
      # 
      # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
      # 
      # - In response: always set - In create/update request: optional
  "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 step status was set 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.
  },
  "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
      # 
      # The keys must exactly match the dimension_definition of the execution.
      # 
      # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
      # 
      # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
      # 
      # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
      # 
      # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
      # 
      # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
      # 
      # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
      # 
      # - In response: present if set by create - In create request: optional - In update request: never set
    {
      "value": "A String",
      "key": "A String",
    },
  ],
  "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
  },
  "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
      # 
      # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
      # 
      # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
      # 
      # - In response: present if previously set. - In create request: optional - In update request: optional
      #
      # # 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
  },
  "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
      # 
      # - In response: always set - In create/update request: never set
}

  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:

    { # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
      #
      # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
      #
      # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
      #
      # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
    "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
        #
        # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
        #
        # Users can also add test results manually by using the test_result field.
      "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
          #
          # - In response: present if set by create or update - In create/update request: optional
        "testProcessDuration": { # 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. # How long it took to run the test process.
            #
            # - In response: present if previously set. - In create/update request: optional
            #
            # # 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
        },
      },
      "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
          #
          # The maximum allowed number of test suite overviews per step is 1000.
          #
          # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
        { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
            #
            # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
          "name": "A String", # The name of the test suite.
              #
              # - In create/response: always set - In update request: never
          "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
              #
              # Note: Multiple test suites can share the same xml_source
              #
              # Returns INVALID_ARGUMENT if the uri format is not supported.
              #
              # - In create/response: optional - In update request: never
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
          "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
              #
              # - In create/response: always set - In update request: never
          "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
        },
      ],
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
          #
          # The exit code of this tool will be used to determine if the test passed.
          #
          # - In response: always set - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
      "testIssues": [ # Issues observed during the test execution.
          #
          # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
          #
          # - In response: present if set by create or update - In create/update request: optional
        { # An abnormal event observed during the test execution.
          "stackTrace": { # A stacktrace. # Optional.
            "exception": "A String", # The stack trace message.
                #
                # Required
          },
          "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
              #
              # Required.
        },
      ],
    },
    "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
    },
    "stepId": "A String", # A unique identifier within a Execution for this Step.
        #
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        #
        # - In response: always set - In create/update request: never set
    "runDuration": { # 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. # How long it took for this step to run.
        #
        # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
        #
        # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
        #
        # # 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
    },
    "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
        #
        # - In response: present if set by create/update request - In create/update request: optional
    "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
        #
        # Users are responsible for managing the key namespace such that keys don't accidentally collide.
        #
        # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
        #
        # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "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 step was created.
        #
        # - 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.
    },
    "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
        #
        # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
        #
        # - In response: always set - In create request: always set - In update request: never set
    "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
        #
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        #
        # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
        #
        # - In response: always set - In create/update request: optional
    "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 step status was set 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.
    },
    "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
        #
        # The keys must exactly match the dimension_definition of the execution.
        #
        # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
        #
        # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
        #
        # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
        #
        # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
        #
        # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
        #
        # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
        #
        # - In response: present if set by create - In create request: optional - In update request: never set
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
    },
    "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
        #
        # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
        #
        # - In response: present if previously set. - In create request: optional - In update request: optional
        #
        # # 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
    },
    "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
        #
        # - In response: always set - In create/update request: never set
  }</pre>
</div>

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

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 Step does not exist

Args:
  projectId: string, A Project id.

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

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

Required. (required)
  stepId: string, A Step id.

Required. (required)

Returns:
  An object of the form:

    { # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
      #
      # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
      #
      # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
      #
      # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
    "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
        #
        # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
        #
        # Users can also add test results manually by using the test_result field.
      "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
          #
          # - In response: present if set by create or update - In create/update request: optional
        "testProcessDuration": { # 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. # How long it took to run the test process.
            #
            # - In response: present if previously set. - In create/update request: optional
            #
            # # 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
        },
      },
      "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
          #
          # The maximum allowed number of test suite overviews per step is 1000.
          #
          # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
        { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
            #
            # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
          "name": "A String", # The name of the test suite.
              #
              # - In create/response: always set - In update request: never
          "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
              #
              # Note: Multiple test suites can share the same xml_source
              #
              # Returns INVALID_ARGUMENT if the uri format is not supported.
              #
              # - In create/response: optional - In update request: never
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
          "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
              #
              # - In create/response: always set - In update request: never
          "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
        },
      ],
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
          #
          # The exit code of this tool will be used to determine if the test passed.
          #
          # - In response: always set - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
      "testIssues": [ # Issues observed during the test execution.
          #
          # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
          #
          # - In response: present if set by create or update - In create/update request: optional
        { # An abnormal event observed during the test execution.
          "stackTrace": { # A stacktrace. # Optional.
            "exception": "A String", # The stack trace message.
                #
                # Required
          },
          "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
              #
              # Required.
        },
      ],
    },
    "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
    },
    "stepId": "A String", # A unique identifier within a Execution for this Step.
        #
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        #
        # - In response: always set - In create/update request: never set
    "runDuration": { # 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. # How long it took for this step to run.
        #
        # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
        #
        # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
        #
        # # 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
    },
    "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
        #
        # - In response: present if set by create/update request - In create/update request: optional
    "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
        #
        # Users are responsible for managing the key namespace such that keys don't accidentally collide.
        #
        # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
        #
        # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "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 step was created.
        #
        # - 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.
    },
    "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
        #
        # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
        #
        # - In response: always set - In create request: always set - In update request: never set
    "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
        #
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        #
        # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
        #
        # - In response: always set - In create/update request: optional
    "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 step status was set 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.
    },
    "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
        #
        # The keys must exactly match the dimension_definition of the execution.
        #
        # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
        #
        # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
        #
        # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
        #
        # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
        #
        # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
        #
        # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
        #
        # - In response: present if set by create - In create request: optional - In update request: never set
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
    },
    "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
        #
        # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
        #
        # - In response: present if previously set. - In create request: optional - In update request: optional
        #
        # # 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
    },
    "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
        #
        # - In response: always set - In create/update request: never set
  }</pre>
</div>

<div class="method">
    <code class="details" id="getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId)</code>
  <pre>Retrieves a PerfMetricsSummary.

May return any of the following error code(s): - NOT_FOUND - The specified PerfMetricsSummary does not exist

Args:
  projectId: string, The cloud project (required)
  historyId: string, A tool results history ID. (required)
  executionId: string, A tool results execution ID. (required)
  stepId: string, A tool results step ID. (required)

Returns:
  An object of the form:

    { # A summary of perf metrics collected and performance environment info
    "stepId": "A String", # A tool results step ID.
    "projectId": "A String", # The cloud project
    "perfEnvironment": { # Encapsulates performance environment info # Describes the environment in which the performance metrics were collected
      "cpuInfo": { # CPU related environment info
        "cpuSpeedInGhz": 3.14, # the CPU clock speed in GHz
        "cpuProcessor": "A String", # description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A'
        "numberOfCores": 42, # the number of CPU cores
      },
      "memoryInfo": { # Memory related environment info
        "memoryTotalInKibibyte": "A String", # Total memory available on the device in KiB
        "memoryCapInKibibyte": "A String", # Maximum memory that can be allocated to the process in KiB
      },
    },
    "historyId": "A String", # A tool results history ID.
    "executionId": "A String", # A tool results execution ID.
    "perfMetrics": [ # Set of resource collected
      "A String",
    ],
  }</pre>
</div>

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

The steps are sorted by creation_time in descending order. The step_id key will be used to order the steps 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 - FAILED_PRECONDITION - if an argument in the request happens to be invalid; e.g. if an attempt is made to list the children of a nonexistent Step - NOT_FOUND - if the containing Execution does not exist

Args:
  projectId: string, A Project id.

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

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

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

Optional.
  pageSize: integer, The maximum number of Steps 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:

    { # Response message for StepService.List.
    "nextPageToken": "A String", # A continuation token to resume the query at the next item.
        #
        # If set, indicates that there are more steps to read, by calling list again with this value in the page_token field.
    "steps": [ # Steps.
      { # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
          #
          # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
          #
          # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
          #
          # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
        "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
            #
            # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
            #
            # Users can also add test results manually by using the test_result field.
          "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
              #
              # - In response: present if set by create or update - In create/update request: optional
            "testProcessDuration": { # 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. # How long it took to run the test process.
                #
                # - In response: present if previously set. - In create/update request: optional
                #
                # # 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
            },
          },
          "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
              #
              # The maximum allowed number of test suite overviews per step is 1000.
              #
              # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
            { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
                #
                # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
              "name": "A String", # The name of the test suite.
                  #
                  # - In create/response: always set - In update request: never
              "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
                  #
                  # - In create/response: always set - In update request: never
              "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
                  #
                  # - In create/response: always set - In update request: never
              "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
                  #
                  # Note: Multiple test suites can share the same xml_source
                  #
                  # Returns INVALID_ARGUMENT if the uri format is not supported.
                  #
                  # - In create/response: optional - In update request: never
                "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                    #
                    # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                    #
                    # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                    #
                    # - In response: always set - In create/update request: always set
              },
              "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
                  #
                  # - In create/response: always set - In update request: never
              "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
                  #
                  # - In create/response: always set - In update request: never
            },
          ],
          "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
              #
              # The exit code of this tool will be used to determine if the test passed.
              #
              # - In response: always set - In create/update request: optional
            "toolLogs": [ # References to any plain text logs output the tool execution.
                #
                # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
                #
                # The maximum allowed number of tool logs per step is 1000.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
              { # A reference to a file.
                "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                    #
                    # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                    #
                    # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                    #
                    # - In response: always set - In create/update request: always set
              },
            ],
            "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
              "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
                  #
                  # - In response: always set - In create/update request: always set
            },
            "toolOutputs": [ # References to opaque files of any format output by the tool execution.
                #
                # The maximum allowed number of tool outputs per step is 1000.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
              { # A reference to a ToolExecution output file.
                "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                    #
                    # - In response: present if set by create/update request - In create/update request: optional
                    #
                    # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
                  "className": "A String", # The name of the class.
                  "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
                  "name": "A String", # The name of the test case.
                      #
                      # Required.
                },
                "output": { # A reference to a file. # A FileReference to an output file.
                    #
                    # - In response: always set - In create/update request: always set
                  "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                      #
                      # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                      #
                      # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                      #
                      # - In response: always set - In create/update request: always 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 creation time of the file.
                    #
                    # - In response: present if set by create/update request - In create/update request: optional
                    #
                    # # 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.
                },
              },
            ],
            "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
                #
                # - In response: present if set by create request - In create request: optional - In update request: never set
              "A String",
            ],
          },
          "testIssues": [ # Issues observed during the test execution.
              #
              # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
              #
              # - In response: present if set by create or update - In create/update request: optional
            { # An abnormal event observed during the test execution.
              "stackTrace": { # A stacktrace. # Optional.
                "exception": "A String", # The stack trace message.
                    #
                    # Required
              },
              "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
                  #
                  # Required.
            },
          ],
        },
        "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
          "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
              #
              # - In response: present if set by create/update request - In create/update request: optional
            "toolLogs": [ # References to any plain text logs output the tool execution.
                #
                # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
                #
                # The maximum allowed number of tool logs per step is 1000.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
              { # A reference to a file.
                "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                    #
                    # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                    #
                    # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                    #
                    # - In response: always set - In create/update request: always set
              },
            ],
            "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
              "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
                  #
                  # - In response: always set - In create/update request: always set
            },
            "toolOutputs": [ # References to opaque files of any format output by the tool execution.
                #
                # The maximum allowed number of tool outputs per step is 1000.
                #
                # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
              { # A reference to a ToolExecution output file.
                "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                    #
                    # - In response: present if set by create/update request - In create/update request: optional
                    #
                    # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
                  "className": "A String", # The name of the class.
                  "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
                  "name": "A String", # The name of the test case.
                      #
                      # Required.
                },
                "output": { # A reference to a file. # A FileReference to an output file.
                    #
                    # - In response: always set - In create/update request: always set
                  "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                      #
                      # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                      #
                      # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                      #
                      # - In response: always set - In create/update request: always 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 creation time of the file.
                    #
                    # - In response: present if set by create/update request - In create/update request: optional
                    #
                    # # 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.
                },
              },
            ],
            "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
                #
                # - In response: present if set by create request - In create request: optional - In update request: never set
              "A String",
            ],
          },
        },
        "stepId": "A String", # A unique identifier within a Execution for this Step.
            #
            # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
            #
            # - In response: always set - In create/update request: never set
        "runDuration": { # 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. # How long it took for this step to run.
            #
            # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
            #
            # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
            #
            # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
            #
            # # 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
        },
        "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
            #
            # - In response: present if set by create/update request - In create/update request: optional
        "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
            #
            # Users are responsible for managing the key namespace such that keys don't accidentally collide.
            #
            # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
            #
            # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
          {
            "value": "A String",
            "key": "A String",
          },
        ],
        "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 step was created.
            #
            # - 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.
        },
        "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
            #
            # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
            #
            # - In response: always set - In create request: always set - In update request: never set
        "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
            #
            # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
            #
            # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
            #
            # - In response: always set - In create/update request: optional
        "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 step status was set 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.
        },
        "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
            #
            # The keys must exactly match the dimension_definition of the execution.
            #
            # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
            #
            # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
            #
            # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
            #
            # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
            #
            # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
            #
            # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
            #
            # - In response: present if set by create - In create request: optional - In update request: never set
          {
            "value": "A String",
            "key": "A String",
          },
        ],
        "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
        },
        "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
            #
            # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
            #
            # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
            #
            # - In response: present if previously set. - In create request: optional - In update request: optional
            #
            # # 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
        },
        "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
            #
            # - In response: always set - In create/update request: never set
      },
    ],
  }</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, stepId, body, requestId=None)</code>
  <pre>Updates an existing Step with the supplied partial entity.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal (e.g try to upload a duplicate xml file), if the updated step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist

Args:
  projectId: string, A Project id.

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

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

Required. (required)
  stepId: string, A Step id.

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

{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
    # 
    # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
    # 
    # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
    # 
    # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
  "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
      #
      # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
      #
      # Users can also add test results manually by using the test_result field.
    "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
        #
        # - In response: present if set by create or update - In create/update request: optional
      "testProcessDuration": { # 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. # How long it took to run the test process.
          #
          # - In response: present if previously set. - In create/update request: optional
          #
          # # 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
      },
    },
    "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
        #
        # The maximum allowed number of test suite overviews per step is 1000.
        #
        # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
      { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
          #
          # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
        "name": "A String", # The name of the test suite.
            #
            # - In create/response: always set - In update request: never
        "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
        "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
        "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
            #
            # Note: Multiple test suites can share the same xml_source
            #
            # Returns INVALID_ARGUMENT if the uri format is not supported.
            #
            # - In create/response: optional - In update request: never
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
        "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
            #
            # - In create/response: always set - In update request: never
        "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
            #
            # - In create/response: always set - In update request: never
      },
    ],
    "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
        #
        # The exit code of this tool will be used to determine if the test passed.
        #
        # - In response: always set - In create/update request: optional
      "toolLogs": [ # References to any plain text logs output the tool execution.
          #
          # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
          #
          # The maximum allowed number of tool logs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a file.
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
      ],
      "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
        "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
            #
            # - In response: always set - In create/update request: always set
      },
      "toolOutputs": [ # References to opaque files of any format output by the tool execution.
          #
          # The maximum allowed number of tool outputs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a ToolExecution output file.
          "testCase": { # A reference to a test case. # The test case to which this output file belongs.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
            "className": "A String", # The name of the class.
            "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
            "name": "A String", # The name of the test case.
                #
                # Required.
          },
          "output": { # A reference to a file. # A FileReference to an output file.
              #
              # - In response: always set - In create/update request: always set
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always 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 creation time of the file.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # # 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.
          },
        },
      ],
      "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
          #
          # - In response: present if set by create request - In create request: optional - In update request: never set
        "A String",
      ],
    },
    "testIssues": [ # Issues observed during the test execution.
        #
        # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
        #
        # - In response: present if set by create or update - In create/update request: optional
      { # An abnormal event observed during the test execution.
        "stackTrace": { # A stacktrace. # Optional.
          "exception": "A String", # The stack trace message.
              #
              # Required
        },
        "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
            #
            # Required.
      },
    ],
  },
  "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
    "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
        #
        # - In response: present if set by create/update request - In create/update request: optional
      "toolLogs": [ # References to any plain text logs output the tool execution.
          #
          # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
          #
          # The maximum allowed number of tool logs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a file.
          "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
              #
              # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
              #
              # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
              #
              # - In response: always set - In create/update request: always set
        },
      ],
      "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
        "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
            #
            # - In response: always set - In create/update request: always set
      },
      "toolOutputs": [ # References to opaque files of any format output by the tool execution.
          #
          # The maximum allowed number of tool outputs per step is 1000.
          #
          # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
        { # A reference to a ToolExecution output file.
          "testCase": { # A reference to a test case. # The test case to which this output file belongs.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
            "className": "A String", # The name of the class.
            "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
            "name": "A String", # The name of the test case.
                #
                # Required.
          },
          "output": { # A reference to a file. # A FileReference to an output file.
              #
              # - In response: always set - In create/update request: always set
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always 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 creation time of the file.
              #
              # - In response: present if set by create/update request - In create/update request: optional
              #
              # # 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.
          },
        },
      ],
      "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
          #
          # - In response: present if set by create request - In create request: optional - In update request: never set
        "A String",
      ],
    },
  },
  "stepId": "A String", # A unique identifier within a Execution for this Step.
      # 
      # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
      # 
      # - In response: always set - In create/update request: never set
  "runDuration": { # 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. # How long it took for this step to run.
      # 
      # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
      # 
      # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
      # 
      # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
      #
      # # 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
  },
  "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
      # 
      # - In response: present if set by create/update request - In create/update request: optional
  "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
      # 
      # Users are responsible for managing the key namespace such that keys don't accidentally collide.
      # 
      # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
      # 
      # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
    {
      "value": "A String",
      "key": "A String",
    },
  ],
  "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 step was created.
      # 
      # - 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.
  },
  "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
      # 
      # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
      # 
      # - In response: always set - In create request: always set - In update request: never set
  "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
      # 
      # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
      # 
      # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
      # 
      # - In response: always set - In create/update request: optional
  "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 step status was set 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.
  },
  "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
      # 
      # The keys must exactly match the dimension_definition of the execution.
      # 
      # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
      # 
      # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
      # 
      # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
      # 
      # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
      # 
      # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
      # 
      # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
      # 
      # - In response: present if set by create - In create request: optional - In update request: never set
    {
      "value": "A String",
      "key": "A String",
    },
  ],
  "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
  },
  "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
      # 
      # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
      # 
      # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
      # 
      # - In response: present if previously set. - In create request: optional - In update request: optional
      #
      # # 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
  },
  "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
      # 
      # - In response: always set - In create/update request: never set
}

  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:

    { # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
      #
      # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
      #
      # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
      #
      # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
    "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
        #
        # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
        #
        # Users can also add test results manually by using the test_result field.
      "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
          #
          # - In response: present if set by create or update - In create/update request: optional
        "testProcessDuration": { # 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. # How long it took to run the test process.
            #
            # - In response: present if previously set. - In create/update request: optional
            #
            # # 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
        },
      },
      "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
          #
          # The maximum allowed number of test suite overviews per step is 1000.
          #
          # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
        { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
            #
            # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
          "name": "A String", # The name of the test suite.
              #
              # - In create/response: always set - In update request: never
          "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
              #
              # Note: Multiple test suites can share the same xml_source
              #
              # Returns INVALID_ARGUMENT if the uri format is not supported.
              #
              # - In create/response: optional - In update request: never
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
          "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
              #
              # - In create/response: always set - In update request: never
          "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
        },
      ],
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
          #
          # The exit code of this tool will be used to determine if the test passed.
          #
          # - In response: always set - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
      "testIssues": [ # Issues observed during the test execution.
          #
          # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
          #
          # - In response: present if set by create or update - In create/update request: optional
        { # An abnormal event observed during the test execution.
          "stackTrace": { # A stacktrace. # Optional.
            "exception": "A String", # The stack trace message.
                #
                # Required
          },
          "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
              #
              # Required.
        },
      ],
    },
    "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
    },
    "stepId": "A String", # A unique identifier within a Execution for this Step.
        #
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        #
        # - In response: always set - In create/update request: never set
    "runDuration": { # 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. # How long it took for this step to run.
        #
        # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
        #
        # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
        #
        # # 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
    },
    "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
        #
        # - In response: present if set by create/update request - In create/update request: optional
    "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
        #
        # Users are responsible for managing the key namespace such that keys don't accidentally collide.
        #
        # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
        #
        # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "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 step was created.
        #
        # - 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.
    },
    "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
        #
        # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
        #
        # - In response: always set - In create request: always set - In update request: never set
    "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
        #
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        #
        # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
        #
        # - In response: always set - In create/update request: optional
    "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 step status was set 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.
    },
    "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
        #
        # The keys must exactly match the dimension_definition of the execution.
        #
        # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
        #
        # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
        #
        # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
        #
        # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
        #
        # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
        #
        # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
        #
        # - In response: present if set by create - In create request: optional - In update request: never set
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
    },
    "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
        #
        # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
        #
        # - In response: present if previously set. - In create request: optional - In update request: optional
        #
        # # 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
    },
    "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
        #
        # - In response: always set - In create/update request: never set
  }</pre>
</div>

<div class="method">
    <code class="details" id="publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body)</code>
  <pre>Publish xml files to an existing Step.

May return any of the following canonical error codes:

- PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal, e.g try to upload a duplicate xml file or a file too large. - NOT_FOUND - if the containing Execution does not exist

Args:
  projectId: string, A Project id.

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

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

Required. (required)
  stepId: string, A Step id. Note: This step must include a TestExecutionStep.

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

{ # Request message for StepService.PublishXunitXmlFiles.
    "xunitXmlFiles": [ # URI of the Xunit XML files to publish.
        # 
        # The maximum size of the file this reference is pointing to is 50MB.
        # 
        # Required.
      { # A reference to a file.
        "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
            #
            # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
            #
            # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
            #
            # - In response: always set - In create/update request: always set
      },
    ],
  }


Returns:
  An object of the form:

    { # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler).
      #
      # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel).
      #
      # Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE
      #
      # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable.
    "testExecutionStep": { # A step that represents running tests. # An execution of a test runner.
        #
        # It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted.
        #
        # Users can also add test results manually by using the test_result field.
      "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution.
          #
          # - In response: present if set by create or update - In create/update request: optional
        "testProcessDuration": { # 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. # How long it took to run the test process.
            #
            # - In response: present if previously set. - In create/update request: optional
            #
            # # 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
        },
      },
      "testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded.
          #
          # The maximum allowed number of test suite overviews per step is 1000.
          #
          # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
        { # A summary of a test suite result either parsed from XML or uploaded directly by a user.
            #
            # Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
          "name": "A String", # The name of the test suite.
              #
              # - In create/response: always set - In update request: never
          "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
          "xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored.
              #
              # Note: Multiple test suites can share the same xml_source
              #
              # Returns INVALID_ARGUMENT if the uri format is not supported.
              #
              # - In create/response: optional - In update request: never
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
          "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user.
              #
              # - In create/response: always set - In update request: never
          "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source.
              #
              # - In create/response: always set - In update request: never
        },
      ],
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner.
          #
          # The exit code of this tool will be used to determine if the test passed.
          #
          # - In response: always set - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
      "testIssues": [ # Issues observed during the test execution.
          #
          # For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging.
          #
          # - In response: present if set by create or update - In create/update request: optional
        { # An abnormal event observed during the test execution.
          "stackTrace": { # A stacktrace. # Optional.
            "exception": "A String", # The stack trace message.
                #
                # Required
          },
          "errorMessage": "A String", # A brief human-readable message describing the abnormal event.
              #
              # Required.
        },
      ],
    },
    "toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
      "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution.
          #
          # - In response: present if set by create/update request - In create/update request: optional
        "toolLogs": [ # References to any plain text logs output the tool execution.
            #
            # This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running.
            #
            # The maximum allowed number of tool logs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a file.
            "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                #
                # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                #
                # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                #
                # - In response: always set - In create/update request: always set
          },
        ],
        "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
          "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful.
              #
              # - In response: always set - In create/update request: always set
        },
        "toolOutputs": [ # References to opaque files of any format output by the tool execution.
            #
            # The maximum allowed number of tool outputs per step is 1000.
            #
            # - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
          { # A reference to a ToolExecution output file.
            "testCase": { # A reference to a test case. # The test case to which this output file belongs.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name.
              "className": "A String", # The name of the class.
              "testSuiteName": "A String", # The name of the test suite to which this test case belongs.
              "name": "A String", # The name of the test case.
                  #
                  # Required.
            },
            "output": { # A reference to a file. # A FileReference to an output file.
                #
                # - In response: always set - In create/update request: always set
              "fileUri": "A String", # The URI of a file stored in Google Cloud Storage.
                  #
                  # For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000
                  #
                  # An INVALID_ARGUMENT error will be returned if the URI format is not supported.
                  #
                  # - In response: always set - In create/update request: always 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 creation time of the file.
                #
                # - In response: present if set by create/update request - In create/update request: optional
                #
                # # 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.
            },
          },
        ],
        "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program).
            #
            # - In response: present if set by create request - In create request: optional - In update request: never set
          "A String",
        ],
      },
    },
    "stepId": "A String", # A unique identifier within a Execution for this Step.
        #
        # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller.
        #
        # - In response: always set - In create/update request: never set
    "runDuration": { # 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. # How long it took for this step to run.
        #
        # If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set.
        #
        # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
        #
        # # 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
    },
    "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true
        #
        # - In response: present if set by create/update request - In create/update request: optional
    "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step.
        #
        # Users are responsible for managing the key namespace such that keys don't accidentally collide.
        #
        # An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters.
        #
        # - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "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 step was created.
        #
        # - 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.
    },
    "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build
        #
        # A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name.
        #
        # - In response: always set - In create request: always set - In update request: never set
    "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE
        #
        # A PRECONDITION_FAILED will be returned if an invalid transition is requested.
        #
        # It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times.
        #
        # - In response: always set - In create/update request: optional
    "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 step status was set 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.
    },
    "dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions.
        #
        # The keys must exactly match the dimension_definition of the execution.
        #
        # For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']`
        #
        # If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']`
        #
        # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset.
        #
        # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution.
        #
        # A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different.
        #
        # A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys.
        #
        # - In response: present if set by create - In create request: optional - In update request: never set
      {
        "value": "A String",
        "key": "A String",
      },
    ],
    "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of 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
    },
    "deviceUsageDuration": { # 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. # How much the device resource is used to perform the test.
        #
        # This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage.
        #
        # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set.
        #
        # - In response: present if previously set. - In create request: optional - In update request: optional
        #
        # # 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
    },
    "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails.
        #
        # - In response: always set - In create/update request: never set
  }</pre>
</div>

</body></html>