1<html><body> 2<style> 3 4body, h1, h2, h3, div, span, p, pre, a { 5 margin: 0; 6 padding: 0; 7 border: 0; 8 font-weight: inherit; 9 font-style: inherit; 10 font-size: 100%; 11 font-family: inherit; 12 vertical-align: baseline; 13} 14 15body { 16 font-size: 13px; 17 padding: 1em; 18} 19 20h1 { 21 font-size: 26px; 22 margin-bottom: 1em; 23} 24 25h2 { 26 font-size: 24px; 27 margin-bottom: 1em; 28} 29 30h3 { 31 font-size: 20px; 32 margin-bottom: 1em; 33 margin-top: 1em; 34} 35 36pre, code { 37 line-height: 1.5; 38 font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace; 39} 40 41pre { 42 margin-top: 0.5em; 43} 44 45h1, h2, h3, p { 46 font-family: Arial, sans serif; 47} 48 49h1, h2, h3 { 50 border-bottom: solid #CCC 1px; 51} 52 53.toc_element { 54 margin-top: 0.5em; 55} 56 57.firstline { 58 margin-left: 2 em; 59} 60 61.method { 62 margin-top: 1em; 63 border: solid 1px #CCC; 64 padding: 1em; 65 background: #EEE; 66} 67 68.details { 69 font-weight: bold; 70 font-size: 14px; 71} 72 73</style> 74 75<h1><a href="toolresults_v1beta3.html">Cloud Tool Results API</a> . <a href="toolresults_v1beta3.projects.html">projects</a> . <a href="toolresults_v1beta3.projects.histories.html">histories</a> . <a href="toolresults_v1beta3.projects.histories.executions.html">executions</a> . <a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps</a></h1> 76<h2>Instance Methods</h2> 77<p class="toc_element"> 78 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.perfMetricsSummary.html">perfMetricsSummary()</a></code> 79</p> 80<p class="firstline">Returns the perfMetricsSummary Resource.</p> 81 82<p class="toc_element"> 83 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.perfSampleSeries.html">perfSampleSeries()</a></code> 84</p> 85<p class="firstline">Returns the perfSampleSeries Resource.</p> 86 87<p class="toc_element"> 88 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.testCases.html">testCases()</a></code> 89</p> 90<p class="firstline">Returns the testCases Resource.</p> 91 92<p class="toc_element"> 93 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.thumbnails.html">thumbnails()</a></code> 94</p> 95<p class="firstline">Returns the thumbnails Resource.</p> 96 97<p class="toc_element"> 98 <code><a href="#create">create(projectId, historyId, executionId, body, requestId=None)</a></code></p> 99<p class="firstline">Creates a Step.</p> 100<p class="toc_element"> 101 <code><a href="#get">get(projectId, historyId, executionId, stepId)</a></code></p> 102<p class="firstline">Gets a Step.</p> 103<p class="toc_element"> 104 <code><a href="#getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId)</a></code></p> 105<p class="firstline">Retrieves a PerfMetricsSummary.</p> 106<p class="toc_element"> 107 <code><a href="#list">list(projectId, historyId, executionId, pageToken=None, pageSize=None)</a></code></p> 108<p class="firstline">Lists Steps for a given Execution.</p> 109<p class="toc_element"> 110 <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p> 111<p class="firstline">Retrieves the next page of results.</p> 112<p class="toc_element"> 113 <code><a href="#patch">patch(projectId, historyId, executionId, stepId, body, requestId=None)</a></code></p> 114<p class="firstline">Updates an existing Step with the supplied partial entity.</p> 115<p class="toc_element"> 116 <code><a href="#publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body)</a></code></p> 117<p class="firstline">Publish xml files to an existing Step.</p> 118<h3>Method Details</h3> 119<div class="method"> 120 <code class="details" id="create">create(projectId, historyId, executionId, body, requestId=None)</code> 121 <pre>Creates a Step. 122 123The returned Step will have the id set. 124 125May return any of the following canonical error codes: 126 127- 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 128 129Args: 130 projectId: string, A Project id. 131 132Required. (required) 133 historyId: string, A History id. 134 135Required. (required) 136 executionId: string, A Execution id. 137 138Required. (required) 139 body: object, The request body. (required) 140 The object takes the form of: 141 142{ # 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). 143 # 144 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 145 # 146 # 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 147 # 148 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 149 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 150 # 151 # 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. 152 # 153 # Users can also add test results manually by using the test_result field. 154 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 155 # 156 # - In response: present if set by create or update - In create/update request: optional 157 "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. 158 # 159 # - In response: present if previously set. - In create/update request: optional 160 # 161 # # Examples 162 # 163 # Example 1: Compute Duration from two Timestamps in pseudo code. 164 # 165 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 166 # 167 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 168 # 169 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 170 # 171 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 172 # 173 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 174 # 175 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 176 # 177 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 178 # 179 # Example 3: Compute Duration from datetime.timedelta in Python. 180 # 181 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 182 # 183 # # JSON Mapping 184 # 185 # 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". 186 "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. 187 "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 188 }, 189 }, 190 "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. 191 # 192 # The maximum allowed number of test suite overviews per step is 1000. 193 # 194 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 195 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 196 # 197 # 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. 198 "name": "A String", # The name of the test suite. 199 # 200 # - In create/response: always set - In update request: never 201 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 202 # 203 # - In create/response: always set - In update request: never 204 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 205 # 206 # - In create/response: always set - In update request: never 207 "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. 208 # 209 # Note: Multiple test suites can share the same xml_source 210 # 211 # Returns INVALID_ARGUMENT if the uri format is not supported. 212 # 213 # - In create/response: optional - In update request: never 214 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 215 # 216 # 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 217 # 218 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 219 # 220 # - In response: always set - In create/update request: always set 221 }, 222 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 223 # 224 # - In create/response: always set - In update request: never 225 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 226 # 227 # - In create/response: always set - In update request: never 228 }, 229 ], 230 "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. 231 # 232 # The exit code of this tool will be used to determine if the test passed. 233 # 234 # - In response: always set - In create/update request: optional 235 "toolLogs": [ # References to any plain text logs output the tool execution. 236 # 237 # 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. 238 # 239 # The maximum allowed number of tool logs per step is 1000. 240 # 241 # - 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 242 { # A reference to a file. 243 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 244 # 245 # 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 246 # 247 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 248 # 249 # - In response: always set - In create/update request: always set 250 }, 251 ], 252 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 253 # 254 # - 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. 255 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 256 # 257 # - In response: always set - In create/update request: always set 258 }, 259 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 260 # 261 # The maximum allowed number of tool outputs per step is 1000. 262 # 263 # - 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 264 { # A reference to a ToolExecution output file. 265 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 266 # 267 # - In response: present if set by create/update request - In create/update request: optional 268 # 269 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 270 "className": "A String", # The name of the class. 271 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 272 "name": "A String", # The name of the test case. 273 # 274 # Required. 275 }, 276 "output": { # A reference to a file. # A FileReference to an output file. 277 # 278 # - In response: always set - In create/update request: always set 279 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 280 # 281 # 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 282 # 283 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 284 # 285 # - In response: always set - In create/update request: always set 286 }, 287 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 288 # 289 # - In response: present if set by create/update request - In create/update request: optional 290 # 291 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 292 # 293 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 294 # 295 # # Examples 296 # 297 # Example 1: Compute Timestamp from POSIX `time()`. 298 # 299 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 300 # 301 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 302 # 303 # struct timeval tv; gettimeofday(&tv, NULL); 304 # 305 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 306 # 307 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 308 # 309 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 310 # 311 # // 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)); 312 # 313 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 314 # 315 # long millis = System.currentTimeMillis(); 316 # 317 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 318 # 319 # 320 # 321 # Example 5: Compute Timestamp from current time in Python. 322 # 323 # timestamp = Timestamp() timestamp.GetCurrentTime() 324 # 325 # # JSON Mapping 326 # 327 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 328 # 329 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 330 # 331 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 332 "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. 333 "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. 334 }, 335 }, 336 ], 337 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 338 # 339 # - In response: present if set by create request - In create request: optional - In update request: never set 340 "A String", 341 ], 342 }, 343 "testIssues": [ # Issues observed during the test execution. 344 # 345 # 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. 346 # 347 # - In response: present if set by create or update - In create/update request: optional 348 { # An issue detected occurring during a test execution. 349 "category": "A String", # Category of issue. Required. 350 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 351 "exception": "A String", # The stack trace message. 352 # 353 # Required 354 }, 355 "severity": "A String", # Severity of issue. Required. 356 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 357 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 358 # 359 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 360 # 361 # Example 1: Pack and unpack a message in C++. 362 # 363 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 364 # 365 # Example 2: Pack and unpack a message in Java. 366 # 367 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 368 # 369 # Example 3: Pack and unpack a message in Python. 370 # 371 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 372 # 373 # Example 4: Pack and unpack a message in Go 374 # 375 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 376 # 377 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 378 # 379 # 380 # 381 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 382 # 383 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 384 # 385 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 386 # 387 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 388 # 389 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 390 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 391 # 392 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 393 # 394 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 395 # 396 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 397 # 398 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 399 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 400 }, 401 "type": "A String", # Type of issue. Required. 402 }, 403 ], 404 }, 405 "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). 406 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 407 # 408 # - In response: present if set by create/update request - In create/update request: optional 409 "toolLogs": [ # References to any plain text logs output the tool execution. 410 # 411 # 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. 412 # 413 # The maximum allowed number of tool logs per step is 1000. 414 # 415 # - 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 416 { # A reference to a file. 417 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 418 # 419 # 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 420 # 421 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 422 # 423 # - In response: always set - In create/update request: always set 424 }, 425 ], 426 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 427 # 428 # - 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. 429 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 430 # 431 # - In response: always set - In create/update request: always set 432 }, 433 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 434 # 435 # The maximum allowed number of tool outputs per step is 1000. 436 # 437 # - 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 438 { # A reference to a ToolExecution output file. 439 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 440 # 441 # - In response: present if set by create/update request - In create/update request: optional 442 # 443 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 444 "className": "A String", # The name of the class. 445 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 446 "name": "A String", # The name of the test case. 447 # 448 # Required. 449 }, 450 "output": { # A reference to a file. # A FileReference to an output file. 451 # 452 # - In response: always set - In create/update request: always set 453 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 454 # 455 # 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 456 # 457 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 458 # 459 # - In response: always set - In create/update request: always set 460 }, 461 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 462 # 463 # - In response: present if set by create/update request - In create/update request: optional 464 # 465 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 466 # 467 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 468 # 469 # # Examples 470 # 471 # Example 1: Compute Timestamp from POSIX `time()`. 472 # 473 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 474 # 475 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 476 # 477 # struct timeval tv; gettimeofday(&tv, NULL); 478 # 479 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 480 # 481 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 482 # 483 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 484 # 485 # // 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)); 486 # 487 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 488 # 489 # long millis = System.currentTimeMillis(); 490 # 491 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 492 # 493 # 494 # 495 # Example 5: Compute Timestamp from current time in Python. 496 # 497 # timestamp = Timestamp() timestamp.GetCurrentTime() 498 # 499 # # JSON Mapping 500 # 501 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 502 # 503 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 504 # 505 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 506 "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. 507 "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. 508 }, 509 }, 510 ], 511 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 512 # 513 # - In response: present if set by create request - In create request: optional - In update request: never set 514 "A String", 515 ], 516 }, 517 }, 518 "stepId": "A String", # A unique identifier within a Execution for this Step. 519 # 520 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 521 # 522 # - In response: always set - In create/update request: never set 523 "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. 524 # 525 # 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. 526 # 527 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 528 # 529 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 530 # 531 # # Examples 532 # 533 # Example 1: Compute Duration from two Timestamps in pseudo code. 534 # 535 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 536 # 537 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 538 # 539 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 540 # 541 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 542 # 543 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 544 # 545 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 546 # 547 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 548 # 549 # Example 3: Compute Duration from datetime.timedelta in Python. 550 # 551 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 552 # 553 # # JSON Mapping 554 # 555 # 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". 556 "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. 557 "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 558 }, 559 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 560 # 561 # - In response: present if set by create/update request - In create/update request: optional 562 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 563 # 564 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 565 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 566 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 567 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 568 "individualOutcome": [ # Step Id and outcome of each individual step. 569 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 570 "outcomeSummary": "A String", 571 "stepId": "A String", 572 "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. 573 # 574 # # Examples 575 # 576 # Example 1: Compute Duration from two Timestamps in pseudo code. 577 # 578 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 579 # 580 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 581 # 582 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 583 # 584 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 585 # 586 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 587 # 588 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 589 # 590 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 591 # 592 # Example 3: Compute Duration from datetime.timedelta in Python. 593 # 594 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 595 # 596 # # JSON Mapping 597 # 598 # 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". 599 "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. 600 "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 601 }, 602 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 603 }, 604 ], 605 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 606 }, 607 }, 608 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 609 # 610 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 611 # 612 # 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. 613 # 614 # - 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 615 { 616 "value": "A String", 617 "key": "A String", 618 }, 619 ], 620 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 621 # 622 # - In response: always set - In create/update request: never set 623 # 624 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 625 # 626 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 627 # 628 # # Examples 629 # 630 # Example 1: Compute Timestamp from POSIX `time()`. 631 # 632 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 633 # 634 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 635 # 636 # struct timeval tv; gettimeofday(&tv, NULL); 637 # 638 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 639 # 640 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 641 # 642 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 643 # 644 # // 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)); 645 # 646 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 647 # 648 # long millis = System.currentTimeMillis(); 649 # 650 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 651 # 652 # 653 # 654 # Example 5: Compute Timestamp from current time in Python. 655 # 656 # timestamp = Timestamp() timestamp.GetCurrentTime() 657 # 658 # # JSON Mapping 659 # 660 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 661 # 662 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 663 # 664 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 665 "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. 666 "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. 667 }, 668 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 669 # 670 # 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. 671 # 672 # - In response: always set - In create request: always set - In update request: never set 673 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 674 # 675 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 676 # 677 # 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. 678 # 679 # - In response: always set - In create/update request: optional 680 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 681 # 682 # This value will be set automatically when state transitions to COMPLETE. 683 # 684 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 685 # 686 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 687 # 688 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 689 # 690 # # Examples 691 # 692 # Example 1: Compute Timestamp from POSIX `time()`. 693 # 694 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 695 # 696 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 697 # 698 # struct timeval tv; gettimeofday(&tv, NULL); 699 # 700 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 701 # 702 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 703 # 704 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 705 # 706 # // 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)); 707 # 708 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 709 # 710 # long millis = System.currentTimeMillis(); 711 # 712 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 713 # 714 # 715 # 716 # Example 5: Compute Timestamp from current time in Python. 717 # 718 # timestamp = Timestamp() timestamp.GetCurrentTime() 719 # 720 # # JSON Mapping 721 # 722 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 723 # 724 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 725 # 726 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 727 "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. 728 "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. 729 }, 730 "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. 731 # 732 # The keys must exactly match the dimension_definition of the execution. 733 # 734 # 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']` 735 # 736 # 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']` 737 # 738 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 739 # 740 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 741 # 742 # 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. 743 # 744 # 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. 745 # 746 # - In response: present if set by create - In create request: optional - In update request: never set 747 { 748 "value": "A String", 749 "key": "A String", 750 }, 751 ], 752 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 753 # 754 # - In response: present if set by create/update request - In create/update request: optional 755 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 756 # 757 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 758 # 759 # Optional 760 "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. 761 # 762 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 763 "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. 764 }, 765 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 766 # 767 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 768 # 769 # Optional 770 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 771 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 772 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 773 }, 774 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 775 # 776 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 777 # 778 # Optional 779 "otherNativeCrash": True or False, # If a native process other than the app crashed. 780 }, 781 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 782 # 783 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 784 # 785 # Optional 786 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 787 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 788 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 789 "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. 790 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 791 }, 792 "summary": "A String", # The simplest way to interpret a result. 793 # 794 # Required 795 }, 796 "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. 797 # 798 # 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. 799 # 800 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 801 # 802 # - In response: present if previously set. - In create request: optional - In update request: optional 803 # 804 # # Examples 805 # 806 # Example 1: Compute Duration from two Timestamps in pseudo code. 807 # 808 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 809 # 810 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 811 # 812 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 813 # 814 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 815 # 816 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 817 # 818 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 819 # 820 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 821 # 822 # Example 3: Compute Duration from datetime.timedelta in Python. 823 # 824 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 825 # 826 # # JSON Mapping 827 # 828 # 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". 829 "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. 830 "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 831 }, 832 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 833 # 834 # - In response: always set - In create/update request: never set 835} 836 837 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 838 839Optional, but strongly recommended. 840 841Returns: 842 An object of the form: 843 844 { # 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). 845 # 846 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 847 # 848 # 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 849 # 850 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 851 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 852 # 853 # 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. 854 # 855 # Users can also add test results manually by using the test_result field. 856 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 857 # 858 # - In response: present if set by create or update - In create/update request: optional 859 "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. 860 # 861 # - In response: present if previously set. - In create/update request: optional 862 # 863 # # Examples 864 # 865 # Example 1: Compute Duration from two Timestamps in pseudo code. 866 # 867 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 868 # 869 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 870 # 871 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 872 # 873 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 874 # 875 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 876 # 877 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 878 # 879 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 880 # 881 # Example 3: Compute Duration from datetime.timedelta in Python. 882 # 883 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 884 # 885 # # JSON Mapping 886 # 887 # 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". 888 "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. 889 "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 890 }, 891 }, 892 "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. 893 # 894 # The maximum allowed number of test suite overviews per step is 1000. 895 # 896 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 897 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 898 # 899 # 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. 900 "name": "A String", # The name of the test suite. 901 # 902 # - In create/response: always set - In update request: never 903 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 904 # 905 # - In create/response: always set - In update request: never 906 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 907 # 908 # - In create/response: always set - In update request: never 909 "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. 910 # 911 # Note: Multiple test suites can share the same xml_source 912 # 913 # Returns INVALID_ARGUMENT if the uri format is not supported. 914 # 915 # - In create/response: optional - In update request: never 916 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 917 # 918 # 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 919 # 920 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 921 # 922 # - In response: always set - In create/update request: always set 923 }, 924 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 925 # 926 # - In create/response: always set - In update request: never 927 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 928 # 929 # - In create/response: always set - In update request: never 930 }, 931 ], 932 "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. 933 # 934 # The exit code of this tool will be used to determine if the test passed. 935 # 936 # - In response: always set - In create/update request: optional 937 "toolLogs": [ # References to any plain text logs output the tool execution. 938 # 939 # 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. 940 # 941 # The maximum allowed number of tool logs per step is 1000. 942 # 943 # - 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 944 { # A reference to a file. 945 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 946 # 947 # 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 948 # 949 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 950 # 951 # - In response: always set - In create/update request: always set 952 }, 953 ], 954 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 955 # 956 # - 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. 957 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 958 # 959 # - In response: always set - In create/update request: always set 960 }, 961 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 962 # 963 # The maximum allowed number of tool outputs per step is 1000. 964 # 965 # - 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 966 { # A reference to a ToolExecution output file. 967 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 968 # 969 # - In response: present if set by create/update request - In create/update request: optional 970 # 971 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 972 "className": "A String", # The name of the class. 973 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 974 "name": "A String", # The name of the test case. 975 # 976 # Required. 977 }, 978 "output": { # A reference to a file. # A FileReference to an output file. 979 # 980 # - In response: always set - In create/update request: always set 981 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 982 # 983 # 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 984 # 985 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 986 # 987 # - In response: always set - In create/update request: always set 988 }, 989 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 990 # 991 # - In response: present if set by create/update request - In create/update request: optional 992 # 993 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 994 # 995 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 996 # 997 # # Examples 998 # 999 # Example 1: Compute Timestamp from POSIX `time()`. 1000 # 1001 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1002 # 1003 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1004 # 1005 # struct timeval tv; gettimeofday(&tv, NULL); 1006 # 1007 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1008 # 1009 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1010 # 1011 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1012 # 1013 # // 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)); 1014 # 1015 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1016 # 1017 # long millis = System.currentTimeMillis(); 1018 # 1019 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1020 # 1021 # 1022 # 1023 # Example 5: Compute Timestamp from current time in Python. 1024 # 1025 # timestamp = Timestamp() timestamp.GetCurrentTime() 1026 # 1027 # # JSON Mapping 1028 # 1029 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1030 # 1031 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1032 # 1033 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1034 "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. 1035 "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. 1036 }, 1037 }, 1038 ], 1039 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 1040 # 1041 # - In response: present if set by create request - In create request: optional - In update request: never set 1042 "A String", 1043 ], 1044 }, 1045 "testIssues": [ # Issues observed during the test execution. 1046 # 1047 # 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. 1048 # 1049 # - In response: present if set by create or update - In create/update request: optional 1050 { # An issue detected occurring during a test execution. 1051 "category": "A String", # Category of issue. Required. 1052 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 1053 "exception": "A String", # The stack trace message. 1054 # 1055 # Required 1056 }, 1057 "severity": "A String", # Severity of issue. Required. 1058 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 1059 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 1060 # 1061 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 1062 # 1063 # Example 1: Pack and unpack a message in C++. 1064 # 1065 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 1066 # 1067 # Example 2: Pack and unpack a message in Java. 1068 # 1069 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 1070 # 1071 # Example 3: Pack and unpack a message in Python. 1072 # 1073 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 1074 # 1075 # Example 4: Pack and unpack a message in Go 1076 # 1077 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 1078 # 1079 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 1080 # 1081 # 1082 # 1083 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 1084 # 1085 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 1086 # 1087 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 1088 # 1089 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 1090 # 1091 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 1092 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 1093 # 1094 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 1095 # 1096 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 1097 # 1098 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 1099 # 1100 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 1101 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 1102 }, 1103 "type": "A String", # Type of issue. Required. 1104 }, 1105 ], 1106 }, 1107 "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). 1108 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 1109 # 1110 # - In response: present if set by create/update request - In create/update request: optional 1111 "toolLogs": [ # References to any plain text logs output the tool execution. 1112 # 1113 # 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. 1114 # 1115 # The maximum allowed number of tool logs per step is 1000. 1116 # 1117 # - 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 1118 { # A reference to a file. 1119 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1120 # 1121 # 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 1122 # 1123 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1124 # 1125 # - In response: always set - In create/update request: always set 1126 }, 1127 ], 1128 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 1129 # 1130 # - 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. 1131 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 1132 # 1133 # - In response: always set - In create/update request: always set 1134 }, 1135 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 1136 # 1137 # The maximum allowed number of tool outputs per step is 1000. 1138 # 1139 # - 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 1140 { # A reference to a ToolExecution output file. 1141 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 1142 # 1143 # - In response: present if set by create/update request - In create/update request: optional 1144 # 1145 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 1146 "className": "A String", # The name of the class. 1147 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 1148 "name": "A String", # The name of the test case. 1149 # 1150 # Required. 1151 }, 1152 "output": { # A reference to a file. # A FileReference to an output file. 1153 # 1154 # - In response: always set - In create/update request: always set 1155 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1156 # 1157 # 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 1158 # 1159 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1160 # 1161 # - In response: always set - In create/update request: always set 1162 }, 1163 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 1164 # 1165 # - In response: present if set by create/update request - In create/update request: optional 1166 # 1167 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 1168 # 1169 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 1170 # 1171 # # Examples 1172 # 1173 # Example 1: Compute Timestamp from POSIX `time()`. 1174 # 1175 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1176 # 1177 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1178 # 1179 # struct timeval tv; gettimeofday(&tv, NULL); 1180 # 1181 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1182 # 1183 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1184 # 1185 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1186 # 1187 # // 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)); 1188 # 1189 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1190 # 1191 # long millis = System.currentTimeMillis(); 1192 # 1193 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1194 # 1195 # 1196 # 1197 # Example 5: Compute Timestamp from current time in Python. 1198 # 1199 # timestamp = Timestamp() timestamp.GetCurrentTime() 1200 # 1201 # # JSON Mapping 1202 # 1203 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1204 # 1205 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1206 # 1207 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1208 "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. 1209 "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. 1210 }, 1211 }, 1212 ], 1213 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 1214 # 1215 # - In response: present if set by create request - In create request: optional - In update request: never set 1216 "A String", 1217 ], 1218 }, 1219 }, 1220 "stepId": "A String", # A unique identifier within a Execution for this Step. 1221 # 1222 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1223 # 1224 # - In response: always set - In create/update request: never set 1225 "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. 1226 # 1227 # 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. 1228 # 1229 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 1230 # 1231 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 1232 # 1233 # # Examples 1234 # 1235 # Example 1: Compute Duration from two Timestamps in pseudo code. 1236 # 1237 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1238 # 1239 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1240 # 1241 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1242 # 1243 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1244 # 1245 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1246 # 1247 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1248 # 1249 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1250 # 1251 # Example 3: Compute Duration from datetime.timedelta in Python. 1252 # 1253 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1254 # 1255 # # JSON Mapping 1256 # 1257 # 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". 1258 "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. 1259 "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 1260 }, 1261 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 1262 # 1263 # - In response: present if set by create/update request - In create/update request: optional 1264 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 1265 # 1266 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 1267 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 1268 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 1269 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 1270 "individualOutcome": [ # Step Id and outcome of each individual step. 1271 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 1272 "outcomeSummary": "A String", 1273 "stepId": "A String", 1274 "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. 1275 # 1276 # # Examples 1277 # 1278 # Example 1: Compute Duration from two Timestamps in pseudo code. 1279 # 1280 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1281 # 1282 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1283 # 1284 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1285 # 1286 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1287 # 1288 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1289 # 1290 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1291 # 1292 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1293 # 1294 # Example 3: Compute Duration from datetime.timedelta in Python. 1295 # 1296 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1297 # 1298 # # JSON Mapping 1299 # 1300 # 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". 1301 "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. 1302 "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 1303 }, 1304 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 1305 }, 1306 ], 1307 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 1308 }, 1309 }, 1310 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 1311 # 1312 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 1313 # 1314 # 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. 1315 # 1316 # - 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 1317 { 1318 "value": "A String", 1319 "key": "A String", 1320 }, 1321 ], 1322 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 1323 # 1324 # - In response: always set - In create/update request: never set 1325 # 1326 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 1327 # 1328 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 1329 # 1330 # # Examples 1331 # 1332 # Example 1: Compute Timestamp from POSIX `time()`. 1333 # 1334 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1335 # 1336 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1337 # 1338 # struct timeval tv; gettimeofday(&tv, NULL); 1339 # 1340 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1341 # 1342 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1343 # 1344 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1345 # 1346 # // 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)); 1347 # 1348 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1349 # 1350 # long millis = System.currentTimeMillis(); 1351 # 1352 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1353 # 1354 # 1355 # 1356 # Example 5: Compute Timestamp from current time in Python. 1357 # 1358 # timestamp = Timestamp() timestamp.GetCurrentTime() 1359 # 1360 # # JSON Mapping 1361 # 1362 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1363 # 1364 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1365 # 1366 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1367 "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. 1368 "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. 1369 }, 1370 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 1371 # 1372 # 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. 1373 # 1374 # - In response: always set - In create request: always set - In update request: never set 1375 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 1376 # 1377 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 1378 # 1379 # 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. 1380 # 1381 # - In response: always set - In create/update request: optional 1382 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 1383 # 1384 # This value will be set automatically when state transitions to COMPLETE. 1385 # 1386 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 1387 # 1388 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 1389 # 1390 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 1391 # 1392 # # Examples 1393 # 1394 # Example 1: Compute Timestamp from POSIX `time()`. 1395 # 1396 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1397 # 1398 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1399 # 1400 # struct timeval tv; gettimeofday(&tv, NULL); 1401 # 1402 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1403 # 1404 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1405 # 1406 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1407 # 1408 # // 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)); 1409 # 1410 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1411 # 1412 # long millis = System.currentTimeMillis(); 1413 # 1414 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1415 # 1416 # 1417 # 1418 # Example 5: Compute Timestamp from current time in Python. 1419 # 1420 # timestamp = Timestamp() timestamp.GetCurrentTime() 1421 # 1422 # # JSON Mapping 1423 # 1424 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1425 # 1426 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1427 # 1428 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1429 "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. 1430 "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. 1431 }, 1432 "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. 1433 # 1434 # The keys must exactly match the dimension_definition of the execution. 1435 # 1436 # 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']` 1437 # 1438 # 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']` 1439 # 1440 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 1441 # 1442 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 1443 # 1444 # 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. 1445 # 1446 # 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. 1447 # 1448 # - In response: present if set by create - In create request: optional - In update request: never set 1449 { 1450 "value": "A String", 1451 "key": "A String", 1452 }, 1453 ], 1454 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 1455 # 1456 # - In response: present if set by create/update request - In create/update request: optional 1457 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 1458 # 1459 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 1460 # 1461 # Optional 1462 "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. 1463 # 1464 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 1465 "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. 1466 }, 1467 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 1468 # 1469 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 1470 # 1471 # Optional 1472 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1473 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1474 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1475 }, 1476 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 1477 # 1478 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1479 # 1480 # Optional 1481 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1482 }, 1483 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 1484 # 1485 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1486 # 1487 # Optional 1488 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 1489 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 1490 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1491 "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. 1492 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1493 }, 1494 "summary": "A String", # The simplest way to interpret a result. 1495 # 1496 # Required 1497 }, 1498 "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. 1499 # 1500 # 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. 1501 # 1502 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 1503 # 1504 # - In response: present if previously set. - In create request: optional - In update request: optional 1505 # 1506 # # Examples 1507 # 1508 # Example 1: Compute Duration from two Timestamps in pseudo code. 1509 # 1510 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1511 # 1512 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1513 # 1514 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1515 # 1516 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1517 # 1518 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1519 # 1520 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1521 # 1522 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1523 # 1524 # Example 3: Compute Duration from datetime.timedelta in Python. 1525 # 1526 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1527 # 1528 # # JSON Mapping 1529 # 1530 # 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". 1531 "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. 1532 "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 1533 }, 1534 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 1535 # 1536 # - In response: always set - In create/update request: never set 1537 }</pre> 1538</div> 1539 1540<div class="method"> 1541 <code class="details" id="get">get(projectId, historyId, executionId, stepId)</code> 1542 <pre>Gets a Step. 1543 1544May return any of the following canonical error codes: 1545 1546- 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 1547 1548Args: 1549 projectId: string, A Project id. 1550 1551Required. (required) 1552 historyId: string, A History id. 1553 1554Required. (required) 1555 executionId: string, A Execution id. 1556 1557Required. (required) 1558 stepId: string, A Step id. 1559 1560Required. (required) 1561 1562Returns: 1563 An object of the form: 1564 1565 { # 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). 1566 # 1567 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 1568 # 1569 # 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 1570 # 1571 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 1572 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 1573 # 1574 # 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. 1575 # 1576 # Users can also add test results manually by using the test_result field. 1577 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 1578 # 1579 # - In response: present if set by create or update - In create/update request: optional 1580 "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. 1581 # 1582 # - In response: present if previously set. - In create/update request: optional 1583 # 1584 # # Examples 1585 # 1586 # Example 1: Compute Duration from two Timestamps in pseudo code. 1587 # 1588 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1589 # 1590 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1591 # 1592 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1593 # 1594 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1595 # 1596 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1597 # 1598 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1599 # 1600 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1601 # 1602 # Example 3: Compute Duration from datetime.timedelta in Python. 1603 # 1604 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1605 # 1606 # # JSON Mapping 1607 # 1608 # 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". 1609 "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. 1610 "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 1611 }, 1612 }, 1613 "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. 1614 # 1615 # The maximum allowed number of test suite overviews per step is 1000. 1616 # 1617 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 1618 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 1619 # 1620 # 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. 1621 "name": "A String", # The name of the test suite. 1622 # 1623 # - In create/response: always set - In update request: never 1624 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 1625 # 1626 # - In create/response: always set - In update request: never 1627 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 1628 # 1629 # - In create/response: always set - In update request: never 1630 "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. 1631 # 1632 # Note: Multiple test suites can share the same xml_source 1633 # 1634 # Returns INVALID_ARGUMENT if the uri format is not supported. 1635 # 1636 # - In create/response: optional - In update request: never 1637 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1638 # 1639 # 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 1640 # 1641 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1642 # 1643 # - In response: always set - In create/update request: always set 1644 }, 1645 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 1646 # 1647 # - In create/response: always set - In update request: never 1648 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 1649 # 1650 # - In create/response: always set - In update request: never 1651 }, 1652 ], 1653 "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. 1654 # 1655 # The exit code of this tool will be used to determine if the test passed. 1656 # 1657 # - In response: always set - In create/update request: optional 1658 "toolLogs": [ # References to any plain text logs output the tool execution. 1659 # 1660 # 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. 1661 # 1662 # The maximum allowed number of tool logs per step is 1000. 1663 # 1664 # - 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 1665 { # A reference to a file. 1666 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1667 # 1668 # 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 1669 # 1670 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1671 # 1672 # - In response: always set - In create/update request: always set 1673 }, 1674 ], 1675 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 1676 # 1677 # - 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. 1678 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 1679 # 1680 # - In response: always set - In create/update request: always set 1681 }, 1682 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 1683 # 1684 # The maximum allowed number of tool outputs per step is 1000. 1685 # 1686 # - 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 1687 { # A reference to a ToolExecution output file. 1688 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 1689 # 1690 # - In response: present if set by create/update request - In create/update request: optional 1691 # 1692 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 1693 "className": "A String", # The name of the class. 1694 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 1695 "name": "A String", # The name of the test case. 1696 # 1697 # Required. 1698 }, 1699 "output": { # A reference to a file. # A FileReference to an output file. 1700 # 1701 # - In response: always set - In create/update request: always set 1702 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1703 # 1704 # 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 1705 # 1706 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1707 # 1708 # - In response: always set - In create/update request: always set 1709 }, 1710 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 1711 # 1712 # - In response: present if set by create/update request - In create/update request: optional 1713 # 1714 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 1715 # 1716 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 1717 # 1718 # # Examples 1719 # 1720 # Example 1: Compute Timestamp from POSIX `time()`. 1721 # 1722 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1723 # 1724 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1725 # 1726 # struct timeval tv; gettimeofday(&tv, NULL); 1727 # 1728 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1729 # 1730 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1731 # 1732 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1733 # 1734 # // 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)); 1735 # 1736 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1737 # 1738 # long millis = System.currentTimeMillis(); 1739 # 1740 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1741 # 1742 # 1743 # 1744 # Example 5: Compute Timestamp from current time in Python. 1745 # 1746 # timestamp = Timestamp() timestamp.GetCurrentTime() 1747 # 1748 # # JSON Mapping 1749 # 1750 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1751 # 1752 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1753 # 1754 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1755 "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. 1756 "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. 1757 }, 1758 }, 1759 ], 1760 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 1761 # 1762 # - In response: present if set by create request - In create request: optional - In update request: never set 1763 "A String", 1764 ], 1765 }, 1766 "testIssues": [ # Issues observed during the test execution. 1767 # 1768 # 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. 1769 # 1770 # - In response: present if set by create or update - In create/update request: optional 1771 { # An issue detected occurring during a test execution. 1772 "category": "A String", # Category of issue. Required. 1773 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 1774 "exception": "A String", # The stack trace message. 1775 # 1776 # Required 1777 }, 1778 "severity": "A String", # Severity of issue. Required. 1779 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 1780 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 1781 # 1782 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 1783 # 1784 # Example 1: Pack and unpack a message in C++. 1785 # 1786 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 1787 # 1788 # Example 2: Pack and unpack a message in Java. 1789 # 1790 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 1791 # 1792 # Example 3: Pack and unpack a message in Python. 1793 # 1794 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 1795 # 1796 # Example 4: Pack and unpack a message in Go 1797 # 1798 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 1799 # 1800 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 1801 # 1802 # 1803 # 1804 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 1805 # 1806 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 1807 # 1808 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 1809 # 1810 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 1811 # 1812 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 1813 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 1814 # 1815 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 1816 # 1817 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 1818 # 1819 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 1820 # 1821 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 1822 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 1823 }, 1824 "type": "A String", # Type of issue. Required. 1825 }, 1826 ], 1827 }, 1828 "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). 1829 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 1830 # 1831 # - In response: present if set by create/update request - In create/update request: optional 1832 "toolLogs": [ # References to any plain text logs output the tool execution. 1833 # 1834 # 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. 1835 # 1836 # The maximum allowed number of tool logs per step is 1000. 1837 # 1838 # - 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 1839 { # A reference to a file. 1840 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1841 # 1842 # 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 1843 # 1844 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1845 # 1846 # - In response: always set - In create/update request: always set 1847 }, 1848 ], 1849 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 1850 # 1851 # - 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. 1852 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 1853 # 1854 # - In response: always set - In create/update request: always set 1855 }, 1856 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 1857 # 1858 # The maximum allowed number of tool outputs per step is 1000. 1859 # 1860 # - 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 1861 { # A reference to a ToolExecution output file. 1862 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 1863 # 1864 # - In response: present if set by create/update request - In create/update request: optional 1865 # 1866 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 1867 "className": "A String", # The name of the class. 1868 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 1869 "name": "A String", # The name of the test case. 1870 # 1871 # Required. 1872 }, 1873 "output": { # A reference to a file. # A FileReference to an output file. 1874 # 1875 # - In response: always set - In create/update request: always set 1876 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 1877 # 1878 # 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 1879 # 1880 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 1881 # 1882 # - In response: always set - In create/update request: always set 1883 }, 1884 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 1885 # 1886 # - In response: present if set by create/update request - In create/update request: optional 1887 # 1888 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 1889 # 1890 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 1891 # 1892 # # Examples 1893 # 1894 # Example 1: Compute Timestamp from POSIX `time()`. 1895 # 1896 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1897 # 1898 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1899 # 1900 # struct timeval tv; gettimeofday(&tv, NULL); 1901 # 1902 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1903 # 1904 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1905 # 1906 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1907 # 1908 # // 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)); 1909 # 1910 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1911 # 1912 # long millis = System.currentTimeMillis(); 1913 # 1914 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1915 # 1916 # 1917 # 1918 # Example 5: Compute Timestamp from current time in Python. 1919 # 1920 # timestamp = Timestamp() timestamp.GetCurrentTime() 1921 # 1922 # # JSON Mapping 1923 # 1924 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 1925 # 1926 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1927 # 1928 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 1929 "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. 1930 "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. 1931 }, 1932 }, 1933 ], 1934 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 1935 # 1936 # - In response: present if set by create request - In create request: optional - In update request: never set 1937 "A String", 1938 ], 1939 }, 1940 }, 1941 "stepId": "A String", # A unique identifier within a Execution for this Step. 1942 # 1943 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1944 # 1945 # - In response: always set - In create/update request: never set 1946 "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. 1947 # 1948 # 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. 1949 # 1950 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 1951 # 1952 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 1953 # 1954 # # Examples 1955 # 1956 # Example 1: Compute Duration from two Timestamps in pseudo code. 1957 # 1958 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1959 # 1960 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1961 # 1962 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1963 # 1964 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1965 # 1966 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1967 # 1968 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1969 # 1970 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1971 # 1972 # Example 3: Compute Duration from datetime.timedelta in Python. 1973 # 1974 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1975 # 1976 # # JSON Mapping 1977 # 1978 # 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". 1979 "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. 1980 "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 1981 }, 1982 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 1983 # 1984 # - In response: present if set by create/update request - In create/update request: optional 1985 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 1986 # 1987 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 1988 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 1989 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 1990 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 1991 "individualOutcome": [ # Step Id and outcome of each individual step. 1992 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 1993 "outcomeSummary": "A String", 1994 "stepId": "A String", 1995 "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. 1996 # 1997 # # Examples 1998 # 1999 # Example 1: Compute Duration from two Timestamps in pseudo code. 2000 # 2001 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2002 # 2003 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2004 # 2005 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2006 # 2007 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2008 # 2009 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2010 # 2011 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2012 # 2013 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2014 # 2015 # Example 3: Compute Duration from datetime.timedelta in Python. 2016 # 2017 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2018 # 2019 # # JSON Mapping 2020 # 2021 # 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". 2022 "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. 2023 "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 2024 }, 2025 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 2026 }, 2027 ], 2028 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 2029 }, 2030 }, 2031 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 2032 # 2033 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 2034 # 2035 # 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. 2036 # 2037 # - 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 2038 { 2039 "value": "A String", 2040 "key": "A String", 2041 }, 2042 ], 2043 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 2044 # 2045 # - In response: always set - In create/update request: never set 2046 # 2047 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2048 # 2049 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2050 # 2051 # # Examples 2052 # 2053 # Example 1: Compute Timestamp from POSIX `time()`. 2054 # 2055 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2056 # 2057 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2058 # 2059 # struct timeval tv; gettimeofday(&tv, NULL); 2060 # 2061 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2062 # 2063 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2064 # 2065 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2066 # 2067 # // 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)); 2068 # 2069 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2070 # 2071 # long millis = System.currentTimeMillis(); 2072 # 2073 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2074 # 2075 # 2076 # 2077 # Example 5: Compute Timestamp from current time in Python. 2078 # 2079 # timestamp = Timestamp() timestamp.GetCurrentTime() 2080 # 2081 # # JSON Mapping 2082 # 2083 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2084 # 2085 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2086 # 2087 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 2088 "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. 2089 "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. 2090 }, 2091 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 2092 # 2093 # 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. 2094 # 2095 # - In response: always set - In create request: always set - In update request: never set 2096 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 2097 # 2098 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 2099 # 2100 # 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. 2101 # 2102 # - In response: always set - In create/update request: optional 2103 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 2104 # 2105 # This value will be set automatically when state transitions to COMPLETE. 2106 # 2107 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 2108 # 2109 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2110 # 2111 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2112 # 2113 # # Examples 2114 # 2115 # Example 1: Compute Timestamp from POSIX `time()`. 2116 # 2117 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2118 # 2119 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2120 # 2121 # struct timeval tv; gettimeofday(&tv, NULL); 2122 # 2123 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2124 # 2125 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2126 # 2127 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2128 # 2129 # // 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)); 2130 # 2131 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2132 # 2133 # long millis = System.currentTimeMillis(); 2134 # 2135 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2136 # 2137 # 2138 # 2139 # Example 5: Compute Timestamp from current time in Python. 2140 # 2141 # timestamp = Timestamp() timestamp.GetCurrentTime() 2142 # 2143 # # JSON Mapping 2144 # 2145 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2146 # 2147 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2148 # 2149 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 2150 "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. 2151 "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. 2152 }, 2153 "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. 2154 # 2155 # The keys must exactly match the dimension_definition of the execution. 2156 # 2157 # 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']` 2158 # 2159 # 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']` 2160 # 2161 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 2162 # 2163 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 2164 # 2165 # 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. 2166 # 2167 # 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. 2168 # 2169 # - In response: present if set by create - In create request: optional - In update request: never set 2170 { 2171 "value": "A String", 2172 "key": "A String", 2173 }, 2174 ], 2175 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 2176 # 2177 # - In response: present if set by create/update request - In create/update request: optional 2178 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 2179 # 2180 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 2181 # 2182 # Optional 2183 "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. 2184 # 2185 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 2186 "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. 2187 }, 2188 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 2189 # 2190 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 2191 # 2192 # Optional 2193 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 2194 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 2195 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 2196 }, 2197 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 2198 # 2199 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 2200 # 2201 # Optional 2202 "otherNativeCrash": True or False, # If a native process other than the app crashed. 2203 }, 2204 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 2205 # 2206 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 2207 # 2208 # Optional 2209 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 2210 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 2211 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 2212 "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. 2213 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 2214 }, 2215 "summary": "A String", # The simplest way to interpret a result. 2216 # 2217 # Required 2218 }, 2219 "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. 2220 # 2221 # 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. 2222 # 2223 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 2224 # 2225 # - In response: present if previously set. - In create request: optional - In update request: optional 2226 # 2227 # # Examples 2228 # 2229 # Example 1: Compute Duration from two Timestamps in pseudo code. 2230 # 2231 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2232 # 2233 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2234 # 2235 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2236 # 2237 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2238 # 2239 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2240 # 2241 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2242 # 2243 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2244 # 2245 # Example 3: Compute Duration from datetime.timedelta in Python. 2246 # 2247 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2248 # 2249 # # JSON Mapping 2250 # 2251 # 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". 2252 "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. 2253 "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 2254 }, 2255 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 2256 # 2257 # - In response: always set - In create/update request: never set 2258 }</pre> 2259</div> 2260 2261<div class="method"> 2262 <code class="details" id="getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId)</code> 2263 <pre>Retrieves a PerfMetricsSummary. 2264 2265May return any of the following error code(s): - NOT_FOUND - The specified PerfMetricsSummary does not exist 2266 2267Args: 2268 projectId: string, The cloud project (required) 2269 historyId: string, A tool results history ID. (required) 2270 executionId: string, A tool results execution ID. (required) 2271 stepId: string, A tool results step ID. (required) 2272 2273Returns: 2274 An object of the form: 2275 2276 { # A summary of perf metrics collected and performance environment info 2277 "stepId": "A String", # A tool results step ID. 2278 "projectId": "A String", # The cloud project 2279 "perfEnvironment": { # Encapsulates performance environment info # Describes the environment in which the performance metrics were collected 2280 "cpuInfo": { # CPU related environment info 2281 "cpuSpeedInGhz": 3.14, # the CPU clock speed in GHz 2282 "cpuProcessor": "A String", # description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A' 2283 "numberOfCores": 42, # the number of CPU cores 2284 }, 2285 "memoryInfo": { # Memory related environment info 2286 "memoryTotalInKibibyte": "A String", # Total memory available on the device in KiB 2287 "memoryCapInKibibyte": "A String", # Maximum memory that can be allocated to the process in KiB 2288 }, 2289 }, 2290 "appStartTime": { 2291 "initialDisplayTime": { # 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. # The time from app start to the first displayed activity being drawn, as reported in Logcat. See https://developer.android.com/topic/performance/launch-time.html#time-initial 2292 # 2293 # # Examples 2294 # 2295 # Example 1: Compute Duration from two Timestamps in pseudo code. 2296 # 2297 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2298 # 2299 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2300 # 2301 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2302 # 2303 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2304 # 2305 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2306 # 2307 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2308 # 2309 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2310 # 2311 # Example 3: Compute Duration from datetime.timedelta in Python. 2312 # 2313 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2314 # 2315 # # JSON Mapping 2316 # 2317 # 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". 2318 "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. 2319 "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 2320 }, 2321 "fullyDrawnTime": { # 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. # Optional. The time from app start to reaching the developer-reported "fully drawn" time. This is only stored if the app includes a call to Activity.reportFullyDrawn(). See https://developer.android.com/topic/performance/launch-time.html#time-full 2322 # 2323 # # Examples 2324 # 2325 # Example 1: Compute Duration from two Timestamps in pseudo code. 2326 # 2327 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2328 # 2329 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2330 # 2331 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2332 # 2333 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2334 # 2335 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2336 # 2337 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2338 # 2339 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2340 # 2341 # Example 3: Compute Duration from datetime.timedelta in Python. 2342 # 2343 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2344 # 2345 # # JSON Mapping 2346 # 2347 # 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". 2348 "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. 2349 "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 2350 }, 2351 }, 2352 "historyId": "A String", # A tool results history ID. 2353 "graphicsStats": { # Graphics statistics for the App. The information is collected from 'adb shell dumpsys graphicsstats'. For more info see: https://developer.android.com/training/testing/performance.html Statistics will only be present for API 23+. # Graphics statistics for the entire run. Statistics are reset at the beginning of the run and collected at the end of the run. 2354 "missedVsyncCount": "A String", # Total "missed vsync" events. 2355 "highInputLatencyCount": "A String", # Total "high input latency" events. 2356 "jankyFrames": "A String", # Total frames with slow render time. Should be <= total_frames. 2357 "buckets": [ # Histogram of frame render times. There should be 154 buckets ranging from [5ms, 6ms) to [4950ms, infinity) 2358 { 2359 "renderMillis": "A String", # Lower bound of render time in milliseconds. 2360 "frameCount": "A String", # Number of frames in the bucket. 2361 }, 2362 ], 2363 "slowBitmapUploadCount": "A String", # Total "slow bitmap upload" events. 2364 "p90Millis": "A String", # 90th percentile frame render time in milliseconds. 2365 "p99Millis": "A String", # 99th percentile frame render time in milliseconds. 2366 "totalFrames": "A String", # Total frames rendered by package. 2367 "p95Millis": "A String", # 95th percentile frame render time in milliseconds. 2368 "slowUiThreadCount": "A String", # Total "slow UI thread" events. 2369 "slowDrawCount": "A String", # Total "slow draw" events. 2370 "p50Millis": "A String", # 50th percentile frame render time in milliseconds. 2371 }, 2372 "executionId": "A String", # A tool results execution ID. 2373 "perfMetrics": [ # Set of resource collected 2374 "A String", 2375 ], 2376 }</pre> 2377</div> 2378 2379<div class="method"> 2380 <code class="details" id="list">list(projectId, historyId, executionId, pageToken=None, pageSize=None)</code> 2381 <pre>Lists Steps for a given Execution. 2382 2383The 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. 2384 2385May return any of the following canonical error codes: 2386 2387- 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 2388 2389Args: 2390 projectId: string, A Project id. 2391 2392Required. (required) 2393 historyId: string, A History id. 2394 2395Required. (required) 2396 executionId: string, A Execution id. 2397 2398Required. (required) 2399 pageToken: string, A continuation token to resume the query at the next item. 2400 2401Optional. 2402 pageSize: integer, The maximum number of Steps to fetch. 2403 2404Default value: 25. The server will use this default if the field is not set or has a value of 0. 2405 2406Optional. 2407 2408Returns: 2409 An object of the form: 2410 2411 { # Response message for StepService.List. 2412 "nextPageToken": "A String", # A continuation token to resume the query at the next item. 2413 # 2414 # If set, indicates that there are more steps to read, by calling list again with this value in the page_token field. 2415 "steps": [ # Steps. 2416 { # 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). 2417 # 2418 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 2419 # 2420 # 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 2421 # 2422 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 2423 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 2424 # 2425 # 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. 2426 # 2427 # Users can also add test results manually by using the test_result field. 2428 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 2429 # 2430 # - In response: present if set by create or update - In create/update request: optional 2431 "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. 2432 # 2433 # - In response: present if previously set. - In create/update request: optional 2434 # 2435 # # Examples 2436 # 2437 # Example 1: Compute Duration from two Timestamps in pseudo code. 2438 # 2439 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2440 # 2441 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2442 # 2443 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2444 # 2445 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2446 # 2447 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2448 # 2449 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2450 # 2451 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2452 # 2453 # Example 3: Compute Duration from datetime.timedelta in Python. 2454 # 2455 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2456 # 2457 # # JSON Mapping 2458 # 2459 # 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". 2460 "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. 2461 "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 2462 }, 2463 }, 2464 "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. 2465 # 2466 # The maximum allowed number of test suite overviews per step is 1000. 2467 # 2468 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 2469 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 2470 # 2471 # 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. 2472 "name": "A String", # The name of the test suite. 2473 # 2474 # - In create/response: always set - In update request: never 2475 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 2476 # 2477 # - In create/response: always set - In update request: never 2478 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 2479 # 2480 # - In create/response: always set - In update request: never 2481 "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. 2482 # 2483 # Note: Multiple test suites can share the same xml_source 2484 # 2485 # Returns INVALID_ARGUMENT if the uri format is not supported. 2486 # 2487 # - In create/response: optional - In update request: never 2488 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 2489 # 2490 # 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 2491 # 2492 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 2493 # 2494 # - In response: always set - In create/update request: always set 2495 }, 2496 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 2497 # 2498 # - In create/response: always set - In update request: never 2499 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 2500 # 2501 # - In create/response: always set - In update request: never 2502 }, 2503 ], 2504 "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. 2505 # 2506 # The exit code of this tool will be used to determine if the test passed. 2507 # 2508 # - In response: always set - In create/update request: optional 2509 "toolLogs": [ # References to any plain text logs output the tool execution. 2510 # 2511 # 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. 2512 # 2513 # The maximum allowed number of tool logs per step is 1000. 2514 # 2515 # - 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 2516 { # A reference to a file. 2517 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 2518 # 2519 # 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 2520 # 2521 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 2522 # 2523 # - In response: always set - In create/update request: always set 2524 }, 2525 ], 2526 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 2527 # 2528 # - 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. 2529 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 2530 # 2531 # - In response: always set - In create/update request: always set 2532 }, 2533 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 2534 # 2535 # The maximum allowed number of tool outputs per step is 1000. 2536 # 2537 # - 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 2538 { # A reference to a ToolExecution output file. 2539 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 2540 # 2541 # - In response: present if set by create/update request - In create/update request: optional 2542 # 2543 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 2544 "className": "A String", # The name of the class. 2545 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 2546 "name": "A String", # The name of the test case. 2547 # 2548 # Required. 2549 }, 2550 "output": { # A reference to a file. # A FileReference to an output file. 2551 # 2552 # - In response: always set - In create/update request: always set 2553 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 2554 # 2555 # 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 2556 # 2557 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 2558 # 2559 # - In response: always set - In create/update request: always set 2560 }, 2561 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 2562 # 2563 # - In response: present if set by create/update request - In create/update request: optional 2564 # 2565 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2566 # 2567 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2568 # 2569 # # Examples 2570 # 2571 # Example 1: Compute Timestamp from POSIX `time()`. 2572 # 2573 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2574 # 2575 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2576 # 2577 # struct timeval tv; gettimeofday(&tv, NULL); 2578 # 2579 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2580 # 2581 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2582 # 2583 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2584 # 2585 # // 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)); 2586 # 2587 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2588 # 2589 # long millis = System.currentTimeMillis(); 2590 # 2591 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2592 # 2593 # 2594 # 2595 # Example 5: Compute Timestamp from current time in Python. 2596 # 2597 # timestamp = Timestamp() timestamp.GetCurrentTime() 2598 # 2599 # # JSON Mapping 2600 # 2601 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2602 # 2603 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2604 # 2605 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 2606 "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. 2607 "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. 2608 }, 2609 }, 2610 ], 2611 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 2612 # 2613 # - In response: present if set by create request - In create request: optional - In update request: never set 2614 "A String", 2615 ], 2616 }, 2617 "testIssues": [ # Issues observed during the test execution. 2618 # 2619 # 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. 2620 # 2621 # - In response: present if set by create or update - In create/update request: optional 2622 { # An issue detected occurring during a test execution. 2623 "category": "A String", # Category of issue. Required. 2624 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 2625 "exception": "A String", # The stack trace message. 2626 # 2627 # Required 2628 }, 2629 "severity": "A String", # Severity of issue. Required. 2630 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 2631 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 2632 # 2633 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 2634 # 2635 # Example 1: Pack and unpack a message in C++. 2636 # 2637 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 2638 # 2639 # Example 2: Pack and unpack a message in Java. 2640 # 2641 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 2642 # 2643 # Example 3: Pack and unpack a message in Python. 2644 # 2645 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 2646 # 2647 # Example 4: Pack and unpack a message in Go 2648 # 2649 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 2650 # 2651 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 2652 # 2653 # 2654 # 2655 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 2656 # 2657 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 2658 # 2659 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 2660 # 2661 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 2662 # 2663 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 2664 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 2665 # 2666 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 2667 # 2668 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 2669 # 2670 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 2671 # 2672 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 2673 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 2674 }, 2675 "type": "A String", # Type of issue. Required. 2676 }, 2677 ], 2678 }, 2679 "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). 2680 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 2681 # 2682 # - In response: present if set by create/update request - In create/update request: optional 2683 "toolLogs": [ # References to any plain text logs output the tool execution. 2684 # 2685 # 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. 2686 # 2687 # The maximum allowed number of tool logs per step is 1000. 2688 # 2689 # - 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 2690 { # A reference to a file. 2691 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 2692 # 2693 # 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 2694 # 2695 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 2696 # 2697 # - In response: always set - In create/update request: always set 2698 }, 2699 ], 2700 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 2701 # 2702 # - 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. 2703 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 2704 # 2705 # - In response: always set - In create/update request: always set 2706 }, 2707 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 2708 # 2709 # The maximum allowed number of tool outputs per step is 1000. 2710 # 2711 # - 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 2712 { # A reference to a ToolExecution output file. 2713 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 2714 # 2715 # - In response: present if set by create/update request - In create/update request: optional 2716 # 2717 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 2718 "className": "A String", # The name of the class. 2719 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 2720 "name": "A String", # The name of the test case. 2721 # 2722 # Required. 2723 }, 2724 "output": { # A reference to a file. # A FileReference to an output file. 2725 # 2726 # - In response: always set - In create/update request: always set 2727 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 2728 # 2729 # 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 2730 # 2731 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 2732 # 2733 # - In response: always set - In create/update request: always set 2734 }, 2735 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 2736 # 2737 # - In response: present if set by create/update request - In create/update request: optional 2738 # 2739 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2740 # 2741 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2742 # 2743 # # Examples 2744 # 2745 # Example 1: Compute Timestamp from POSIX `time()`. 2746 # 2747 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2748 # 2749 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2750 # 2751 # struct timeval tv; gettimeofday(&tv, NULL); 2752 # 2753 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2754 # 2755 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2756 # 2757 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2758 # 2759 # // 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)); 2760 # 2761 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2762 # 2763 # long millis = System.currentTimeMillis(); 2764 # 2765 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2766 # 2767 # 2768 # 2769 # Example 5: Compute Timestamp from current time in Python. 2770 # 2771 # timestamp = Timestamp() timestamp.GetCurrentTime() 2772 # 2773 # # JSON Mapping 2774 # 2775 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2776 # 2777 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2778 # 2779 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 2780 "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. 2781 "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. 2782 }, 2783 }, 2784 ], 2785 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 2786 # 2787 # - In response: present if set by create request - In create request: optional - In update request: never set 2788 "A String", 2789 ], 2790 }, 2791 }, 2792 "stepId": "A String", # A unique identifier within a Execution for this Step. 2793 # 2794 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 2795 # 2796 # - In response: always set - In create/update request: never set 2797 "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. 2798 # 2799 # 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. 2800 # 2801 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 2802 # 2803 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 2804 # 2805 # # Examples 2806 # 2807 # Example 1: Compute Duration from two Timestamps in pseudo code. 2808 # 2809 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2810 # 2811 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2812 # 2813 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2814 # 2815 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2816 # 2817 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2818 # 2819 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2820 # 2821 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2822 # 2823 # Example 3: Compute Duration from datetime.timedelta in Python. 2824 # 2825 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2826 # 2827 # # JSON Mapping 2828 # 2829 # 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". 2830 "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. 2831 "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 2832 }, 2833 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 2834 # 2835 # - In response: present if set by create/update request - In create/update request: optional 2836 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 2837 # 2838 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 2839 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 2840 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 2841 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 2842 "individualOutcome": [ # Step Id and outcome of each individual step. 2843 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 2844 "outcomeSummary": "A String", 2845 "stepId": "A String", 2846 "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. 2847 # 2848 # # Examples 2849 # 2850 # Example 1: Compute Duration from two Timestamps in pseudo code. 2851 # 2852 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 2853 # 2854 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 2855 # 2856 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 2857 # 2858 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 2859 # 2860 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 2861 # 2862 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 2863 # 2864 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 2865 # 2866 # Example 3: Compute Duration from datetime.timedelta in Python. 2867 # 2868 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 2869 # 2870 # # JSON Mapping 2871 # 2872 # 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". 2873 "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. 2874 "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 2875 }, 2876 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 2877 }, 2878 ], 2879 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 2880 }, 2881 }, 2882 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 2883 # 2884 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 2885 # 2886 # 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. 2887 # 2888 # - 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 2889 { 2890 "value": "A String", 2891 "key": "A String", 2892 }, 2893 ], 2894 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 2895 # 2896 # - In response: always set - In create/update request: never set 2897 # 2898 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2899 # 2900 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2901 # 2902 # # Examples 2903 # 2904 # Example 1: Compute Timestamp from POSIX `time()`. 2905 # 2906 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2907 # 2908 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2909 # 2910 # struct timeval tv; gettimeofday(&tv, NULL); 2911 # 2912 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2913 # 2914 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2915 # 2916 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2917 # 2918 # // 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)); 2919 # 2920 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2921 # 2922 # long millis = System.currentTimeMillis(); 2923 # 2924 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2925 # 2926 # 2927 # 2928 # Example 5: Compute Timestamp from current time in Python. 2929 # 2930 # timestamp = Timestamp() timestamp.GetCurrentTime() 2931 # 2932 # # JSON Mapping 2933 # 2934 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2935 # 2936 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2937 # 2938 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 2939 "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. 2940 "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. 2941 }, 2942 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 2943 # 2944 # 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. 2945 # 2946 # - In response: always set - In create request: always set - In update request: never set 2947 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 2948 # 2949 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 2950 # 2951 # 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. 2952 # 2953 # - In response: always set - In create/update request: optional 2954 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 2955 # 2956 # This value will be set automatically when state transitions to COMPLETE. 2957 # 2958 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 2959 # 2960 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 2961 # 2962 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 2963 # 2964 # # Examples 2965 # 2966 # Example 1: Compute Timestamp from POSIX `time()`. 2967 # 2968 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 2969 # 2970 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 2971 # 2972 # struct timeval tv; gettimeofday(&tv, NULL); 2973 # 2974 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 2975 # 2976 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 2977 # 2978 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 2979 # 2980 # // 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)); 2981 # 2982 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 2983 # 2984 # long millis = System.currentTimeMillis(); 2985 # 2986 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 2987 # 2988 # 2989 # 2990 # Example 5: Compute Timestamp from current time in Python. 2991 # 2992 # timestamp = Timestamp() timestamp.GetCurrentTime() 2993 # 2994 # # JSON Mapping 2995 # 2996 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 2997 # 2998 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 2999 # 3000 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 3001 "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. 3002 "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. 3003 }, 3004 "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. 3005 # 3006 # The keys must exactly match the dimension_definition of the execution. 3007 # 3008 # 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']` 3009 # 3010 # 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']` 3011 # 3012 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 3013 # 3014 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 3015 # 3016 # 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. 3017 # 3018 # 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. 3019 # 3020 # - In response: present if set by create - In create request: optional - In update request: never set 3021 { 3022 "value": "A String", 3023 "key": "A String", 3024 }, 3025 ], 3026 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 3027 # 3028 # - In response: present if set by create/update request - In create/update request: optional 3029 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 3030 # 3031 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 3032 # 3033 # Optional 3034 "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. 3035 # 3036 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 3037 "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. 3038 }, 3039 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 3040 # 3041 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 3042 # 3043 # Optional 3044 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 3045 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 3046 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 3047 }, 3048 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 3049 # 3050 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 3051 # 3052 # Optional 3053 "otherNativeCrash": True or False, # If a native process other than the app crashed. 3054 }, 3055 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 3056 # 3057 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 3058 # 3059 # Optional 3060 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 3061 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 3062 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 3063 "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. 3064 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 3065 }, 3066 "summary": "A String", # The simplest way to interpret a result. 3067 # 3068 # Required 3069 }, 3070 "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. 3071 # 3072 # 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. 3073 # 3074 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 3075 # 3076 # - In response: present if previously set. - In create request: optional - In update request: optional 3077 # 3078 # # Examples 3079 # 3080 # Example 1: Compute Duration from two Timestamps in pseudo code. 3081 # 3082 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3083 # 3084 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3085 # 3086 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3087 # 3088 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3089 # 3090 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3091 # 3092 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3093 # 3094 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3095 # 3096 # Example 3: Compute Duration from datetime.timedelta in Python. 3097 # 3098 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3099 # 3100 # # JSON Mapping 3101 # 3102 # 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". 3103 "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. 3104 "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 3105 }, 3106 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 3107 # 3108 # - In response: always set - In create/update request: never set 3109 }, 3110 ], 3111 }</pre> 3112</div> 3113 3114<div class="method"> 3115 <code class="details" id="list_next">list_next(previous_request, previous_response)</code> 3116 <pre>Retrieves the next page of results. 3117 3118Args: 3119 previous_request: The request for the previous page. (required) 3120 previous_response: The response from the request for the previous page. (required) 3121 3122Returns: 3123 A request object that you can call 'execute()' on to request the next 3124 page. Returns None if there are no more items in the collection. 3125 </pre> 3126</div> 3127 3128<div class="method"> 3129 <code class="details" id="patch">patch(projectId, historyId, executionId, stepId, body, requestId=None)</code> 3130 <pre>Updates an existing Step with the supplied partial entity. 3131 3132May return any of the following canonical error codes: 3133 3134- 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 3135 3136Args: 3137 projectId: string, A Project id. 3138 3139Required. (required) 3140 historyId: string, A History id. 3141 3142Required. (required) 3143 executionId: string, A Execution id. 3144 3145Required. (required) 3146 stepId: string, A Step id. 3147 3148Required. (required) 3149 body: object, The request body. (required) 3150 The object takes the form of: 3151 3152{ # 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). 3153 # 3154 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 3155 # 3156 # 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 3157 # 3158 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 3159 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 3160 # 3161 # 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. 3162 # 3163 # Users can also add test results manually by using the test_result field. 3164 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 3165 # 3166 # - In response: present if set by create or update - In create/update request: optional 3167 "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. 3168 # 3169 # - In response: present if previously set. - In create/update request: optional 3170 # 3171 # # Examples 3172 # 3173 # Example 1: Compute Duration from two Timestamps in pseudo code. 3174 # 3175 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3176 # 3177 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3178 # 3179 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3180 # 3181 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3182 # 3183 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3184 # 3185 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3186 # 3187 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3188 # 3189 # Example 3: Compute Duration from datetime.timedelta in Python. 3190 # 3191 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3192 # 3193 # # JSON Mapping 3194 # 3195 # 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". 3196 "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. 3197 "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 3198 }, 3199 }, 3200 "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. 3201 # 3202 # The maximum allowed number of test suite overviews per step is 1000. 3203 # 3204 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 3205 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 3206 # 3207 # 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. 3208 "name": "A String", # The name of the test suite. 3209 # 3210 # - In create/response: always set - In update request: never 3211 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 3212 # 3213 # - In create/response: always set - In update request: never 3214 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 3215 # 3216 # - In create/response: always set - In update request: never 3217 "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. 3218 # 3219 # Note: Multiple test suites can share the same xml_source 3220 # 3221 # Returns INVALID_ARGUMENT if the uri format is not supported. 3222 # 3223 # - In create/response: optional - In update request: never 3224 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3225 # 3226 # 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 3227 # 3228 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3229 # 3230 # - In response: always set - In create/update request: always set 3231 }, 3232 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 3233 # 3234 # - In create/response: always set - In update request: never 3235 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 3236 # 3237 # - In create/response: always set - In update request: never 3238 }, 3239 ], 3240 "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. 3241 # 3242 # The exit code of this tool will be used to determine if the test passed. 3243 # 3244 # - In response: always set - In create/update request: optional 3245 "toolLogs": [ # References to any plain text logs output the tool execution. 3246 # 3247 # 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. 3248 # 3249 # The maximum allowed number of tool logs per step is 1000. 3250 # 3251 # - 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 3252 { # A reference to a file. 3253 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3254 # 3255 # 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 3256 # 3257 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3258 # 3259 # - In response: always set - In create/update request: always set 3260 }, 3261 ], 3262 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 3263 # 3264 # - 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. 3265 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 3266 # 3267 # - In response: always set - In create/update request: always set 3268 }, 3269 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 3270 # 3271 # The maximum allowed number of tool outputs per step is 1000. 3272 # 3273 # - 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 3274 { # A reference to a ToolExecution output file. 3275 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 3276 # 3277 # - In response: present if set by create/update request - In create/update request: optional 3278 # 3279 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 3280 "className": "A String", # The name of the class. 3281 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 3282 "name": "A String", # The name of the test case. 3283 # 3284 # Required. 3285 }, 3286 "output": { # A reference to a file. # A FileReference to an output file. 3287 # 3288 # - In response: always set - In create/update request: always set 3289 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3290 # 3291 # 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 3292 # 3293 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3294 # 3295 # - In response: always set - In create/update request: always set 3296 }, 3297 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 3298 # 3299 # - In response: present if set by create/update request - In create/update request: optional 3300 # 3301 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 3302 # 3303 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 3304 # 3305 # # Examples 3306 # 3307 # Example 1: Compute Timestamp from POSIX `time()`. 3308 # 3309 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 3310 # 3311 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 3312 # 3313 # struct timeval tv; gettimeofday(&tv, NULL); 3314 # 3315 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 3316 # 3317 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 3318 # 3319 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 3320 # 3321 # // 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)); 3322 # 3323 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 3324 # 3325 # long millis = System.currentTimeMillis(); 3326 # 3327 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 3328 # 3329 # 3330 # 3331 # Example 5: Compute Timestamp from current time in Python. 3332 # 3333 # timestamp = Timestamp() timestamp.GetCurrentTime() 3334 # 3335 # # JSON Mapping 3336 # 3337 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 3338 # 3339 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 3340 # 3341 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 3342 "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. 3343 "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. 3344 }, 3345 }, 3346 ], 3347 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 3348 # 3349 # - In response: present if set by create request - In create request: optional - In update request: never set 3350 "A String", 3351 ], 3352 }, 3353 "testIssues": [ # Issues observed during the test execution. 3354 # 3355 # 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. 3356 # 3357 # - In response: present if set by create or update - In create/update request: optional 3358 { # An issue detected occurring during a test execution. 3359 "category": "A String", # Category of issue. Required. 3360 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 3361 "exception": "A String", # The stack trace message. 3362 # 3363 # Required 3364 }, 3365 "severity": "A String", # Severity of issue. Required. 3366 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 3367 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 3368 # 3369 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 3370 # 3371 # Example 1: Pack and unpack a message in C++. 3372 # 3373 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 3374 # 3375 # Example 2: Pack and unpack a message in Java. 3376 # 3377 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 3378 # 3379 # Example 3: Pack and unpack a message in Python. 3380 # 3381 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 3382 # 3383 # Example 4: Pack and unpack a message in Go 3384 # 3385 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 3386 # 3387 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 3388 # 3389 # 3390 # 3391 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 3392 # 3393 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 3394 # 3395 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 3396 # 3397 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 3398 # 3399 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 3400 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 3401 # 3402 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 3403 # 3404 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 3405 # 3406 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 3407 # 3408 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 3409 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 3410 }, 3411 "type": "A String", # Type of issue. Required. 3412 }, 3413 ], 3414 }, 3415 "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). 3416 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 3417 # 3418 # - In response: present if set by create/update request - In create/update request: optional 3419 "toolLogs": [ # References to any plain text logs output the tool execution. 3420 # 3421 # 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. 3422 # 3423 # The maximum allowed number of tool logs per step is 1000. 3424 # 3425 # - 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 3426 { # A reference to a file. 3427 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3428 # 3429 # 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 3430 # 3431 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3432 # 3433 # - In response: always set - In create/update request: always set 3434 }, 3435 ], 3436 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 3437 # 3438 # - 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. 3439 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 3440 # 3441 # - In response: always set - In create/update request: always set 3442 }, 3443 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 3444 # 3445 # The maximum allowed number of tool outputs per step is 1000. 3446 # 3447 # - 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 3448 { # A reference to a ToolExecution output file. 3449 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 3450 # 3451 # - In response: present if set by create/update request - In create/update request: optional 3452 # 3453 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 3454 "className": "A String", # The name of the class. 3455 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 3456 "name": "A String", # The name of the test case. 3457 # 3458 # Required. 3459 }, 3460 "output": { # A reference to a file. # A FileReference to an output file. 3461 # 3462 # - In response: always set - In create/update request: always set 3463 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3464 # 3465 # 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 3466 # 3467 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3468 # 3469 # - In response: always set - In create/update request: always set 3470 }, 3471 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 3472 # 3473 # - In response: present if set by create/update request - In create/update request: optional 3474 # 3475 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 3476 # 3477 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 3478 # 3479 # # Examples 3480 # 3481 # Example 1: Compute Timestamp from POSIX `time()`. 3482 # 3483 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 3484 # 3485 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 3486 # 3487 # struct timeval tv; gettimeofday(&tv, NULL); 3488 # 3489 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 3490 # 3491 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 3492 # 3493 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 3494 # 3495 # // 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)); 3496 # 3497 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 3498 # 3499 # long millis = System.currentTimeMillis(); 3500 # 3501 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 3502 # 3503 # 3504 # 3505 # Example 5: Compute Timestamp from current time in Python. 3506 # 3507 # timestamp = Timestamp() timestamp.GetCurrentTime() 3508 # 3509 # # JSON Mapping 3510 # 3511 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 3512 # 3513 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 3514 # 3515 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 3516 "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. 3517 "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. 3518 }, 3519 }, 3520 ], 3521 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 3522 # 3523 # - In response: present if set by create request - In create request: optional - In update request: never set 3524 "A String", 3525 ], 3526 }, 3527 }, 3528 "stepId": "A String", # A unique identifier within a Execution for this Step. 3529 # 3530 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 3531 # 3532 # - In response: always set - In create/update request: never set 3533 "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. 3534 # 3535 # 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. 3536 # 3537 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 3538 # 3539 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 3540 # 3541 # # Examples 3542 # 3543 # Example 1: Compute Duration from two Timestamps in pseudo code. 3544 # 3545 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3546 # 3547 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3548 # 3549 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3550 # 3551 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3552 # 3553 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3554 # 3555 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3556 # 3557 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3558 # 3559 # Example 3: Compute Duration from datetime.timedelta in Python. 3560 # 3561 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3562 # 3563 # # JSON Mapping 3564 # 3565 # 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". 3566 "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. 3567 "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 3568 }, 3569 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 3570 # 3571 # - In response: present if set by create/update request - In create/update request: optional 3572 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 3573 # 3574 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 3575 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 3576 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 3577 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 3578 "individualOutcome": [ # Step Id and outcome of each individual step. 3579 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 3580 "outcomeSummary": "A String", 3581 "stepId": "A String", 3582 "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. 3583 # 3584 # # Examples 3585 # 3586 # Example 1: Compute Duration from two Timestamps in pseudo code. 3587 # 3588 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3589 # 3590 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3591 # 3592 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3593 # 3594 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3595 # 3596 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3597 # 3598 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3599 # 3600 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3601 # 3602 # Example 3: Compute Duration from datetime.timedelta in Python. 3603 # 3604 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3605 # 3606 # # JSON Mapping 3607 # 3608 # 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". 3609 "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. 3610 "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 3611 }, 3612 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 3613 }, 3614 ], 3615 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 3616 }, 3617 }, 3618 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 3619 # 3620 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 3621 # 3622 # 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. 3623 # 3624 # - 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 3625 { 3626 "value": "A String", 3627 "key": "A String", 3628 }, 3629 ], 3630 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 3631 # 3632 # - In response: always set - In create/update request: never set 3633 # 3634 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 3635 # 3636 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 3637 # 3638 # # Examples 3639 # 3640 # Example 1: Compute Timestamp from POSIX `time()`. 3641 # 3642 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 3643 # 3644 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 3645 # 3646 # struct timeval tv; gettimeofday(&tv, NULL); 3647 # 3648 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 3649 # 3650 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 3651 # 3652 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 3653 # 3654 # // 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)); 3655 # 3656 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 3657 # 3658 # long millis = System.currentTimeMillis(); 3659 # 3660 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 3661 # 3662 # 3663 # 3664 # Example 5: Compute Timestamp from current time in Python. 3665 # 3666 # timestamp = Timestamp() timestamp.GetCurrentTime() 3667 # 3668 # # JSON Mapping 3669 # 3670 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 3671 # 3672 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 3673 # 3674 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 3675 "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. 3676 "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. 3677 }, 3678 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 3679 # 3680 # 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. 3681 # 3682 # - In response: always set - In create request: always set - In update request: never set 3683 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 3684 # 3685 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 3686 # 3687 # 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. 3688 # 3689 # - In response: always set - In create/update request: optional 3690 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 3691 # 3692 # This value will be set automatically when state transitions to COMPLETE. 3693 # 3694 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 3695 # 3696 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 3697 # 3698 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 3699 # 3700 # # Examples 3701 # 3702 # Example 1: Compute Timestamp from POSIX `time()`. 3703 # 3704 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 3705 # 3706 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 3707 # 3708 # struct timeval tv; gettimeofday(&tv, NULL); 3709 # 3710 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 3711 # 3712 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 3713 # 3714 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 3715 # 3716 # // 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)); 3717 # 3718 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 3719 # 3720 # long millis = System.currentTimeMillis(); 3721 # 3722 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 3723 # 3724 # 3725 # 3726 # Example 5: Compute Timestamp from current time in Python. 3727 # 3728 # timestamp = Timestamp() timestamp.GetCurrentTime() 3729 # 3730 # # JSON Mapping 3731 # 3732 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 3733 # 3734 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 3735 # 3736 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 3737 "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. 3738 "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. 3739 }, 3740 "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. 3741 # 3742 # The keys must exactly match the dimension_definition of the execution. 3743 # 3744 # 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']` 3745 # 3746 # 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']` 3747 # 3748 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 3749 # 3750 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 3751 # 3752 # 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. 3753 # 3754 # 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. 3755 # 3756 # - In response: present if set by create - In create request: optional - In update request: never set 3757 { 3758 "value": "A String", 3759 "key": "A String", 3760 }, 3761 ], 3762 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 3763 # 3764 # - In response: present if set by create/update request - In create/update request: optional 3765 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 3766 # 3767 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 3768 # 3769 # Optional 3770 "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. 3771 # 3772 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 3773 "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. 3774 }, 3775 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 3776 # 3777 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 3778 # 3779 # Optional 3780 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 3781 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 3782 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 3783 }, 3784 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 3785 # 3786 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 3787 # 3788 # Optional 3789 "otherNativeCrash": True or False, # If a native process other than the app crashed. 3790 }, 3791 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 3792 # 3793 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 3794 # 3795 # Optional 3796 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 3797 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 3798 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 3799 "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. 3800 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 3801 }, 3802 "summary": "A String", # The simplest way to interpret a result. 3803 # 3804 # Required 3805 }, 3806 "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. 3807 # 3808 # 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. 3809 # 3810 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 3811 # 3812 # - In response: present if previously set. - In create request: optional - In update request: optional 3813 # 3814 # # Examples 3815 # 3816 # Example 1: Compute Duration from two Timestamps in pseudo code. 3817 # 3818 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3819 # 3820 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3821 # 3822 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3823 # 3824 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3825 # 3826 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3827 # 3828 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3829 # 3830 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3831 # 3832 # Example 3: Compute Duration from datetime.timedelta in Python. 3833 # 3834 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3835 # 3836 # # JSON Mapping 3837 # 3838 # 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". 3839 "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. 3840 "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 3841 }, 3842 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 3843 # 3844 # - In response: always set - In create/update request: never set 3845} 3846 3847 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 3848 3849Optional, but strongly recommended. 3850 3851Returns: 3852 An object of the form: 3853 3854 { # 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). 3855 # 3856 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 3857 # 3858 # 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 3859 # 3860 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 3861 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 3862 # 3863 # 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. 3864 # 3865 # Users can also add test results manually by using the test_result field. 3866 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 3867 # 3868 # - In response: present if set by create or update - In create/update request: optional 3869 "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. 3870 # 3871 # - In response: present if previously set. - In create/update request: optional 3872 # 3873 # # Examples 3874 # 3875 # Example 1: Compute Duration from two Timestamps in pseudo code. 3876 # 3877 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 3878 # 3879 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 3880 # 3881 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 3882 # 3883 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 3884 # 3885 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 3886 # 3887 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 3888 # 3889 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 3890 # 3891 # Example 3: Compute Duration from datetime.timedelta in Python. 3892 # 3893 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 3894 # 3895 # # JSON Mapping 3896 # 3897 # 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". 3898 "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. 3899 "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 3900 }, 3901 }, 3902 "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. 3903 # 3904 # The maximum allowed number of test suite overviews per step is 1000. 3905 # 3906 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 3907 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 3908 # 3909 # 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. 3910 "name": "A String", # The name of the test suite. 3911 # 3912 # - In create/response: always set - In update request: never 3913 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 3914 # 3915 # - In create/response: always set - In update request: never 3916 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 3917 # 3918 # - In create/response: always set - In update request: never 3919 "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. 3920 # 3921 # Note: Multiple test suites can share the same xml_source 3922 # 3923 # Returns INVALID_ARGUMENT if the uri format is not supported. 3924 # 3925 # - In create/response: optional - In update request: never 3926 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3927 # 3928 # 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 3929 # 3930 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3931 # 3932 # - In response: always set - In create/update request: always set 3933 }, 3934 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 3935 # 3936 # - In create/response: always set - In update request: never 3937 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 3938 # 3939 # - In create/response: always set - In update request: never 3940 }, 3941 ], 3942 "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. 3943 # 3944 # The exit code of this tool will be used to determine if the test passed. 3945 # 3946 # - In response: always set - In create/update request: optional 3947 "toolLogs": [ # References to any plain text logs output the tool execution. 3948 # 3949 # 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. 3950 # 3951 # The maximum allowed number of tool logs per step is 1000. 3952 # 3953 # - 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 3954 { # A reference to a file. 3955 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3956 # 3957 # 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 3958 # 3959 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3960 # 3961 # - In response: always set - In create/update request: always set 3962 }, 3963 ], 3964 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 3965 # 3966 # - 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. 3967 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 3968 # 3969 # - In response: always set - In create/update request: always set 3970 }, 3971 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 3972 # 3973 # The maximum allowed number of tool outputs per step is 1000. 3974 # 3975 # - 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 3976 { # A reference to a ToolExecution output file. 3977 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 3978 # 3979 # - In response: present if set by create/update request - In create/update request: optional 3980 # 3981 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 3982 "className": "A String", # The name of the class. 3983 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 3984 "name": "A String", # The name of the test case. 3985 # 3986 # Required. 3987 }, 3988 "output": { # A reference to a file. # A FileReference to an output file. 3989 # 3990 # - In response: always set - In create/update request: always set 3991 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 3992 # 3993 # 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 3994 # 3995 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 3996 # 3997 # - In response: always set - In create/update request: always set 3998 }, 3999 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 4000 # 4001 # - In response: present if set by create/update request - In create/update request: optional 4002 # 4003 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4004 # 4005 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4006 # 4007 # # Examples 4008 # 4009 # Example 1: Compute Timestamp from POSIX `time()`. 4010 # 4011 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4012 # 4013 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4014 # 4015 # struct timeval tv; gettimeofday(&tv, NULL); 4016 # 4017 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4018 # 4019 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4020 # 4021 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4022 # 4023 # // 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)); 4024 # 4025 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4026 # 4027 # long millis = System.currentTimeMillis(); 4028 # 4029 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4030 # 4031 # 4032 # 4033 # Example 5: Compute Timestamp from current time in Python. 4034 # 4035 # timestamp = Timestamp() timestamp.GetCurrentTime() 4036 # 4037 # # JSON Mapping 4038 # 4039 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4040 # 4041 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4042 # 4043 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4044 "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. 4045 "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. 4046 }, 4047 }, 4048 ], 4049 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 4050 # 4051 # - In response: present if set by create request - In create request: optional - In update request: never set 4052 "A String", 4053 ], 4054 }, 4055 "testIssues": [ # Issues observed during the test execution. 4056 # 4057 # 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. 4058 # 4059 # - In response: present if set by create or update - In create/update request: optional 4060 { # An issue detected occurring during a test execution. 4061 "category": "A String", # Category of issue. Required. 4062 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 4063 "exception": "A String", # The stack trace message. 4064 # 4065 # Required 4066 }, 4067 "severity": "A String", # Severity of issue. Required. 4068 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 4069 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 4070 # 4071 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 4072 # 4073 # Example 1: Pack and unpack a message in C++. 4074 # 4075 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 4076 # 4077 # Example 2: Pack and unpack a message in Java. 4078 # 4079 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 4080 # 4081 # Example 3: Pack and unpack a message in Python. 4082 # 4083 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 4084 # 4085 # Example 4: Pack and unpack a message in Go 4086 # 4087 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 4088 # 4089 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 4090 # 4091 # 4092 # 4093 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 4094 # 4095 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 4096 # 4097 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 4098 # 4099 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 4100 # 4101 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 4102 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 4103 # 4104 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 4105 # 4106 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 4107 # 4108 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 4109 # 4110 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 4111 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 4112 }, 4113 "type": "A String", # Type of issue. Required. 4114 }, 4115 ], 4116 }, 4117 "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). 4118 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 4119 # 4120 # - In response: present if set by create/update request - In create/update request: optional 4121 "toolLogs": [ # References to any plain text logs output the tool execution. 4122 # 4123 # 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. 4124 # 4125 # The maximum allowed number of tool logs per step is 1000. 4126 # 4127 # - 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 4128 { # A reference to a file. 4129 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4130 # 4131 # 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 4132 # 4133 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4134 # 4135 # - In response: always set - In create/update request: always set 4136 }, 4137 ], 4138 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 4139 # 4140 # - 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. 4141 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 4142 # 4143 # - In response: always set - In create/update request: always set 4144 }, 4145 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 4146 # 4147 # The maximum allowed number of tool outputs per step is 1000. 4148 # 4149 # - 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 4150 { # A reference to a ToolExecution output file. 4151 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 4152 # 4153 # - In response: present if set by create/update request - In create/update request: optional 4154 # 4155 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 4156 "className": "A String", # The name of the class. 4157 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 4158 "name": "A String", # The name of the test case. 4159 # 4160 # Required. 4161 }, 4162 "output": { # A reference to a file. # A FileReference to an output file. 4163 # 4164 # - In response: always set - In create/update request: always set 4165 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4166 # 4167 # 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 4168 # 4169 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4170 # 4171 # - In response: always set - In create/update request: always set 4172 }, 4173 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 4174 # 4175 # - In response: present if set by create/update request - In create/update request: optional 4176 # 4177 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4178 # 4179 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4180 # 4181 # # Examples 4182 # 4183 # Example 1: Compute Timestamp from POSIX `time()`. 4184 # 4185 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4186 # 4187 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4188 # 4189 # struct timeval tv; gettimeofday(&tv, NULL); 4190 # 4191 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4192 # 4193 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4194 # 4195 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4196 # 4197 # // 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)); 4198 # 4199 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4200 # 4201 # long millis = System.currentTimeMillis(); 4202 # 4203 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4204 # 4205 # 4206 # 4207 # Example 5: Compute Timestamp from current time in Python. 4208 # 4209 # timestamp = Timestamp() timestamp.GetCurrentTime() 4210 # 4211 # # JSON Mapping 4212 # 4213 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4214 # 4215 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4216 # 4217 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4218 "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. 4219 "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. 4220 }, 4221 }, 4222 ], 4223 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 4224 # 4225 # - In response: present if set by create request - In create request: optional - In update request: never set 4226 "A String", 4227 ], 4228 }, 4229 }, 4230 "stepId": "A String", # A unique identifier within a Execution for this Step. 4231 # 4232 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 4233 # 4234 # - In response: always set - In create/update request: never set 4235 "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. 4236 # 4237 # 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. 4238 # 4239 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 4240 # 4241 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 4242 # 4243 # # Examples 4244 # 4245 # Example 1: Compute Duration from two Timestamps in pseudo code. 4246 # 4247 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 4248 # 4249 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 4250 # 4251 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 4252 # 4253 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 4254 # 4255 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 4256 # 4257 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 4258 # 4259 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 4260 # 4261 # Example 3: Compute Duration from datetime.timedelta in Python. 4262 # 4263 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 4264 # 4265 # # JSON Mapping 4266 # 4267 # 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". 4268 "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. 4269 "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 4270 }, 4271 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 4272 # 4273 # - In response: present if set by create/update request - In create/update request: optional 4274 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 4275 # 4276 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 4277 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 4278 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 4279 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 4280 "individualOutcome": [ # Step Id and outcome of each individual step. 4281 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 4282 "outcomeSummary": "A String", 4283 "stepId": "A String", 4284 "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. 4285 # 4286 # # Examples 4287 # 4288 # Example 1: Compute Duration from two Timestamps in pseudo code. 4289 # 4290 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 4291 # 4292 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 4293 # 4294 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 4295 # 4296 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 4297 # 4298 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 4299 # 4300 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 4301 # 4302 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 4303 # 4304 # Example 3: Compute Duration from datetime.timedelta in Python. 4305 # 4306 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 4307 # 4308 # # JSON Mapping 4309 # 4310 # 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". 4311 "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. 4312 "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 4313 }, 4314 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 4315 }, 4316 ], 4317 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 4318 }, 4319 }, 4320 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 4321 # 4322 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 4323 # 4324 # 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. 4325 # 4326 # - 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 4327 { 4328 "value": "A String", 4329 "key": "A String", 4330 }, 4331 ], 4332 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 4333 # 4334 # - In response: always set - In create/update request: never set 4335 # 4336 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4337 # 4338 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4339 # 4340 # # Examples 4341 # 4342 # Example 1: Compute Timestamp from POSIX `time()`. 4343 # 4344 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4345 # 4346 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4347 # 4348 # struct timeval tv; gettimeofday(&tv, NULL); 4349 # 4350 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4351 # 4352 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4353 # 4354 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4355 # 4356 # // 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)); 4357 # 4358 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4359 # 4360 # long millis = System.currentTimeMillis(); 4361 # 4362 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4363 # 4364 # 4365 # 4366 # Example 5: Compute Timestamp from current time in Python. 4367 # 4368 # timestamp = Timestamp() timestamp.GetCurrentTime() 4369 # 4370 # # JSON Mapping 4371 # 4372 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4373 # 4374 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4375 # 4376 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4377 "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. 4378 "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. 4379 }, 4380 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 4381 # 4382 # 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. 4383 # 4384 # - In response: always set - In create request: always set - In update request: never set 4385 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 4386 # 4387 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 4388 # 4389 # 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. 4390 # 4391 # - In response: always set - In create/update request: optional 4392 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 4393 # 4394 # This value will be set automatically when state transitions to COMPLETE. 4395 # 4396 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 4397 # 4398 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4399 # 4400 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4401 # 4402 # # Examples 4403 # 4404 # Example 1: Compute Timestamp from POSIX `time()`. 4405 # 4406 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4407 # 4408 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4409 # 4410 # struct timeval tv; gettimeofday(&tv, NULL); 4411 # 4412 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4413 # 4414 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4415 # 4416 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4417 # 4418 # // 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)); 4419 # 4420 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4421 # 4422 # long millis = System.currentTimeMillis(); 4423 # 4424 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4425 # 4426 # 4427 # 4428 # Example 5: Compute Timestamp from current time in Python. 4429 # 4430 # timestamp = Timestamp() timestamp.GetCurrentTime() 4431 # 4432 # # JSON Mapping 4433 # 4434 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4435 # 4436 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4437 # 4438 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4439 "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. 4440 "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. 4441 }, 4442 "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. 4443 # 4444 # The keys must exactly match the dimension_definition of the execution. 4445 # 4446 # 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']` 4447 # 4448 # 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']` 4449 # 4450 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 4451 # 4452 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 4453 # 4454 # 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. 4455 # 4456 # 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. 4457 # 4458 # - In response: present if set by create - In create request: optional - In update request: never set 4459 { 4460 "value": "A String", 4461 "key": "A String", 4462 }, 4463 ], 4464 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 4465 # 4466 # - In response: present if set by create/update request - In create/update request: optional 4467 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 4468 # 4469 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 4470 # 4471 # Optional 4472 "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. 4473 # 4474 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 4475 "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. 4476 }, 4477 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 4478 # 4479 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 4480 # 4481 # Optional 4482 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 4483 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 4484 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 4485 }, 4486 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 4487 # 4488 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 4489 # 4490 # Optional 4491 "otherNativeCrash": True or False, # If a native process other than the app crashed. 4492 }, 4493 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 4494 # 4495 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 4496 # 4497 # Optional 4498 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 4499 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 4500 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 4501 "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. 4502 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 4503 }, 4504 "summary": "A String", # The simplest way to interpret a result. 4505 # 4506 # Required 4507 }, 4508 "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. 4509 # 4510 # 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. 4511 # 4512 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 4513 # 4514 # - In response: present if previously set. - In create request: optional - In update request: optional 4515 # 4516 # # Examples 4517 # 4518 # Example 1: Compute Duration from two Timestamps in pseudo code. 4519 # 4520 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 4521 # 4522 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 4523 # 4524 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 4525 # 4526 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 4527 # 4528 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 4529 # 4530 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 4531 # 4532 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 4533 # 4534 # Example 3: Compute Duration from datetime.timedelta in Python. 4535 # 4536 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 4537 # 4538 # # JSON Mapping 4539 # 4540 # 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". 4541 "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. 4542 "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 4543 }, 4544 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 4545 # 4546 # - In response: always set - In create/update request: never set 4547 }</pre> 4548</div> 4549 4550<div class="method"> 4551 <code class="details" id="publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body)</code> 4552 <pre>Publish xml files to an existing Step. 4553 4554May return any of the following canonical error codes: 4555 4556- 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 4557 4558Args: 4559 projectId: string, A Project id. 4560 4561Required. (required) 4562 historyId: string, A History id. 4563 4564Required. (required) 4565 executionId: string, A Execution id. 4566 4567Required. (required) 4568 stepId: string, A Step id. Note: This step must include a TestExecutionStep. 4569 4570Required. (required) 4571 body: object, The request body. (required) 4572 The object takes the form of: 4573 4574{ # Request message for StepService.PublishXunitXmlFiles. 4575 "xunitXmlFiles": [ # URI of the Xunit XML files to publish. 4576 # 4577 # The maximum size of the file this reference is pointing to is 50MB. 4578 # 4579 # Required. 4580 { # A reference to a file. 4581 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4582 # 4583 # 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 4584 # 4585 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4586 # 4587 # - In response: always set - In create/update request: always set 4588 }, 4589 ], 4590 } 4591 4592 4593Returns: 4594 An object of the form: 4595 4596 { # 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). 4597 # 4598 # Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). 4599 # 4600 # 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 4601 # 4602 # A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. 4603 "testExecutionStep": { # A step that represents running tests. # An execution of a test runner. 4604 # 4605 # 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. 4606 # 4607 # Users can also add test results manually by using the test_result field. 4608 "testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. 4609 # 4610 # - In response: present if set by create or update - In create/update request: optional 4611 "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. 4612 # 4613 # - In response: present if previously set. - In create/update request: optional 4614 # 4615 # # Examples 4616 # 4617 # Example 1: Compute Duration from two Timestamps in pseudo code. 4618 # 4619 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 4620 # 4621 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 4622 # 4623 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 4624 # 4625 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 4626 # 4627 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 4628 # 4629 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 4630 # 4631 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 4632 # 4633 # Example 3: Compute Duration from datetime.timedelta in Python. 4634 # 4635 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 4636 # 4637 # # JSON Mapping 4638 # 4639 # 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". 4640 "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. 4641 "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 4642 }, 4643 }, 4644 "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. 4645 # 4646 # The maximum allowed number of test suite overviews per step is 1000. 4647 # 4648 # - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead) 4649 { # A summary of a test suite result either parsed from XML or uploaded directly by a user. 4650 # 4651 # 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. 4652 "name": "A String", # The name of the test suite. 4653 # 4654 # - In create/response: always set - In update request: never 4655 "errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. 4656 # 4657 # - In create/response: always set - In update request: never 4658 "totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. 4659 # 4660 # - In create/response: always set - In update request: never 4661 "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. 4662 # 4663 # Note: Multiple test suites can share the same xml_source 4664 # 4665 # Returns INVALID_ARGUMENT if the uri format is not supported. 4666 # 4667 # - In create/response: optional - In update request: never 4668 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4669 # 4670 # 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 4671 # 4672 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4673 # 4674 # - In response: always set - In create/update request: always set 4675 }, 4676 "failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. 4677 # 4678 # - In create/response: always set - In update request: never 4679 "skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. 4680 # 4681 # - In create/response: always set - In update request: never 4682 }, 4683 ], 4684 "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. 4685 # 4686 # The exit code of this tool will be used to determine if the test passed. 4687 # 4688 # - In response: always set - In create/update request: optional 4689 "toolLogs": [ # References to any plain text logs output the tool execution. 4690 # 4691 # 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. 4692 # 4693 # The maximum allowed number of tool logs per step is 1000. 4694 # 4695 # - 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 4696 { # A reference to a file. 4697 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4698 # 4699 # 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 4700 # 4701 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4702 # 4703 # - In response: always set - In create/update request: always set 4704 }, 4705 ], 4706 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 4707 # 4708 # - 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. 4709 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 4710 # 4711 # - In response: always set - In create/update request: always set 4712 }, 4713 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 4714 # 4715 # The maximum allowed number of tool outputs per step is 1000. 4716 # 4717 # - 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 4718 { # A reference to a ToolExecution output file. 4719 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 4720 # 4721 # - In response: present if set by create/update request - In create/update request: optional 4722 # 4723 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 4724 "className": "A String", # The name of the class. 4725 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 4726 "name": "A String", # The name of the test case. 4727 # 4728 # Required. 4729 }, 4730 "output": { # A reference to a file. # A FileReference to an output file. 4731 # 4732 # - In response: always set - In create/update request: always set 4733 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4734 # 4735 # 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 4736 # 4737 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4738 # 4739 # - In response: always set - In create/update request: always set 4740 }, 4741 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 4742 # 4743 # - In response: present if set by create/update request - In create/update request: optional 4744 # 4745 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4746 # 4747 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4748 # 4749 # # Examples 4750 # 4751 # Example 1: Compute Timestamp from POSIX `time()`. 4752 # 4753 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4754 # 4755 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4756 # 4757 # struct timeval tv; gettimeofday(&tv, NULL); 4758 # 4759 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4760 # 4761 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4762 # 4763 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4764 # 4765 # // 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)); 4766 # 4767 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4768 # 4769 # long millis = System.currentTimeMillis(); 4770 # 4771 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4772 # 4773 # 4774 # 4775 # Example 5: Compute Timestamp from current time in Python. 4776 # 4777 # timestamp = Timestamp() timestamp.GetCurrentTime() 4778 # 4779 # # JSON Mapping 4780 # 4781 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4782 # 4783 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4784 # 4785 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4786 "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. 4787 "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. 4788 }, 4789 }, 4790 ], 4791 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 4792 # 4793 # - In response: present if set by create request - In create request: optional - In update request: never set 4794 "A String", 4795 ], 4796 }, 4797 "testIssues": [ # Issues observed during the test execution. 4798 # 4799 # 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. 4800 # 4801 # - In response: present if set by create or update - In create/update request: optional 4802 { # An issue detected occurring during a test execution. 4803 "category": "A String", # Category of issue. Required. 4804 "stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings. 4805 "exception": "A String", # The stack trace message. 4806 # 4807 # Required 4808 }, 4809 "severity": "A String", # Severity of issue. Required. 4810 "errorMessage": "A String", # A brief human-readable message describing the issue. Required. 4811 "warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings 4812 # 4813 # Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. 4814 # 4815 # Example 1: Pack and unpack a message in C++. 4816 # 4817 # Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } 4818 # 4819 # Example 2: Pack and unpack a message in Java. 4820 # 4821 # Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } 4822 # 4823 # Example 3: Pack and unpack a message in Python. 4824 # 4825 # foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... 4826 # 4827 # Example 4: Pack and unpack a message in Go 4828 # 4829 # foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } 4830 # 4831 # The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". 4832 # 4833 # 4834 # 4835 # JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: 4836 # 4837 # package google.profile; message Person { string first_name = 1; string last_name = 2; } 4838 # 4839 # { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } 4840 # 4841 # If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]): 4842 # 4843 # { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } 4844 "typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). 4845 # 4846 # In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: 4847 # 4848 # * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a [google.protobuf.Type][] value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) 4849 # 4850 # Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. 4851 # 4852 # Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics. 4853 "value": "A String", # Must be a valid serialized protocol buffer of the above specified type. 4854 }, 4855 "type": "A String", # Type of issue. Required. 4856 }, 4857 ], 4858 }, 4859 "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). 4860 "toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. 4861 # 4862 # - In response: present if set by create/update request - In create/update request: optional 4863 "toolLogs": [ # References to any plain text logs output the tool execution. 4864 # 4865 # 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. 4866 # 4867 # The maximum allowed number of tool logs per step is 1000. 4868 # 4869 # - 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 4870 { # A reference to a file. 4871 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4872 # 4873 # 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 4874 # 4875 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4876 # 4877 # - In response: always set - In create/update request: always set 4878 }, 4879 ], 4880 "exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. 4881 # 4882 # - 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. 4883 "number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. 4884 # 4885 # - In response: always set - In create/update request: always set 4886 }, 4887 "toolOutputs": [ # References to opaque files of any format output by the tool execution. 4888 # 4889 # The maximum allowed number of tool outputs per step is 1000. 4890 # 4891 # - 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 4892 { # A reference to a ToolExecution output file. 4893 "testCase": { # A reference to a test case. # The test case to which this output file belongs. 4894 # 4895 # - In response: present if set by create/update request - In create/update request: optional 4896 # 4897 # Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. 4898 "className": "A String", # The name of the class. 4899 "testSuiteName": "A String", # The name of the test suite to which this test case belongs. 4900 "name": "A String", # The name of the test case. 4901 # 4902 # Required. 4903 }, 4904 "output": { # A reference to a file. # A FileReference to an output file. 4905 # 4906 # - In response: always set - In create/update request: always set 4907 "fileUri": "A String", # The URI of a file stored in Google Cloud Storage. 4908 # 4909 # 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 4910 # 4911 # An INVALID_ARGUMENT error will be returned if the URI format is not supported. 4912 # 4913 # - In response: always set - In create/update request: always set 4914 }, 4915 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The creation time of the file. 4916 # 4917 # - In response: present if set by create/update request - In create/update request: optional 4918 # 4919 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 4920 # 4921 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 4922 # 4923 # # Examples 4924 # 4925 # Example 1: Compute Timestamp from POSIX `time()`. 4926 # 4927 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 4928 # 4929 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 4930 # 4931 # struct timeval tv; gettimeofday(&tv, NULL); 4932 # 4933 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 4934 # 4935 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 4936 # 4937 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 4938 # 4939 # // 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)); 4940 # 4941 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 4942 # 4943 # long millis = System.currentTimeMillis(); 4944 # 4945 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 4946 # 4947 # 4948 # 4949 # Example 5: Compute Timestamp from current time in Python. 4950 # 4951 # timestamp = Timestamp() timestamp.GetCurrentTime() 4952 # 4953 # # JSON Mapping 4954 # 4955 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 4956 # 4957 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 4958 # 4959 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 4960 "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. 4961 "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. 4962 }, 4963 }, 4964 ], 4965 "commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). 4966 # 4967 # - In response: present if set by create request - In create request: optional - In update request: never set 4968 "A String", 4969 ], 4970 }, 4971 }, 4972 "stepId": "A String", # A unique identifier within a Execution for this Step. 4973 # 4974 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 4975 # 4976 # - In response: always set - In create/update request: never set 4977 "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. 4978 # 4979 # 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. 4980 # 4981 # PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. 4982 # 4983 # - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional 4984 # 4985 # # Examples 4986 # 4987 # Example 1: Compute Duration from two Timestamps in pseudo code. 4988 # 4989 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 4990 # 4991 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 4992 # 4993 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 4994 # 4995 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 4996 # 4997 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 4998 # 4999 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 5000 # 5001 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 5002 # 5003 # Example 3: Compute Duration from datetime.timedelta in Python. 5004 # 5005 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 5006 # 5007 # # JSON Mapping 5008 # 5009 # 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". 5010 "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. 5011 "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 5012 }, 5013 "description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true 5014 # 5015 # - In response: present if set by create/update request - In create/update request: optional 5016 "multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. 5017 # 5018 # - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional 5019 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 5020 "primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step. 5021 "primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step. 5022 "individualOutcome": [ # Step Id and outcome of each individual step. 5023 { # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration. 5024 "outcomeSummary": "A String", 5025 "stepId": "A String", 5026 "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. 5027 # 5028 # # Examples 5029 # 5030 # Example 1: Compute Duration from two Timestamps in pseudo code. 5031 # 5032 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 5033 # 5034 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 5035 # 5036 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 5037 # 5038 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 5039 # 5040 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 5041 # 5042 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 5043 # 5044 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 5045 # 5046 # Example 3: Compute Duration from datetime.timedelta in Python. 5047 # 5048 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 5049 # 5050 # # JSON Mapping 5051 # 5052 # 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". 5053 "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. 5054 "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 5055 }, 5056 "multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0. 5057 }, 5058 ], 5059 "rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group. 5060 }, 5061 }, 5062 "labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. 5063 # 5064 # Users are responsible for managing the key namespace such that keys don't accidentally collide. 5065 # 5066 # 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. 5067 # 5068 # - 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 5069 { 5070 "value": "A String", 5071 "key": "A String", 5072 }, 5073 ], 5074 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step was created. 5075 # 5076 # - In response: always set - In create/update request: never set 5077 # 5078 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 5079 # 5080 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 5081 # 5082 # # Examples 5083 # 5084 # Example 1: Compute Timestamp from POSIX `time()`. 5085 # 5086 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 5087 # 5088 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 5089 # 5090 # struct timeval tv; gettimeofday(&tv, NULL); 5091 # 5092 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 5093 # 5094 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 5095 # 5096 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 5097 # 5098 # // 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)); 5099 # 5100 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 5101 # 5102 # long millis = System.currentTimeMillis(); 5103 # 5104 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 5105 # 5106 # 5107 # 5108 # Example 5: Compute Timestamp from current time in Python. 5109 # 5110 # timestamp = Timestamp() timestamp.GetCurrentTime() 5111 # 5112 # # JSON Mapping 5113 # 5114 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 5115 # 5116 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 5117 # 5118 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 5119 "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. 5120 "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. 5121 }, 5122 "name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build 5123 # 5124 # 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. 5125 # 5126 # - In response: always set - In create request: always set - In update request: never set 5127 "state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE 5128 # 5129 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 5130 # 5131 # 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. 5132 # 5133 # - In response: always set - In create/update request: optional 5134 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the step status was set to complete. 5135 # 5136 # This value will be set automatically when state transitions to COMPLETE. 5137 # 5138 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 5139 # 5140 # All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap second table is needed for interpretation, using a [24-hour linear smear](https://developers.google.com/time/smear). 5141 # 5142 # The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings. 5143 # 5144 # # Examples 5145 # 5146 # Example 1: Compute Timestamp from POSIX `time()`. 5147 # 5148 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 5149 # 5150 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 5151 # 5152 # struct timeval tv; gettimeofday(&tv, NULL); 5153 # 5154 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 5155 # 5156 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 5157 # 5158 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 5159 # 5160 # // 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)); 5161 # 5162 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 5163 # 5164 # long millis = System.currentTimeMillis(); 5165 # 5166 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 5167 # 5168 # 5169 # 5170 # Example 5: Compute Timestamp from current time in Python. 5171 # 5172 # timestamp = Timestamp() timestamp.GetCurrentTime() 5173 # 5174 # # JSON Mapping 5175 # 5176 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required. A proto3 JSON serializer should always use UTC (as indicated by "Z") when printing the Timestamp type and a proto3 JSON parser should be able to accept both UTC and other timezones (as indicated by an offset). 5177 # 5178 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 5179 # 5180 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString) method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D ) to obtain a formatter capable of generating timestamps in this format. 5181 "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. 5182 "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. 5183 }, 5184 "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. 5185 # 5186 # The keys must exactly match the dimension_definition of the execution. 5187 # 5188 # 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']` 5189 # 5190 # 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']` 5191 # 5192 # If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. 5193 # 5194 # A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. 5195 # 5196 # 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. 5197 # 5198 # 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. 5199 # 5200 # - In response: present if set by create - In create request: optional - In update request: never set 5201 { 5202 "value": "A String", 5203 "key": "A String", 5204 }, 5205 ], 5206 "outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE 5207 # 5208 # - In response: present if set by create/update request - In create/update request: optional 5209 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 5210 # 5211 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 5212 # 5213 # Optional 5214 "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. 5215 # 5216 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 5217 "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. 5218 }, 5219 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 5220 # 5221 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 5222 # 5223 # Optional 5224 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 5225 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 5226 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 5227 }, 5228 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 5229 # 5230 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 5231 # 5232 # Optional 5233 "otherNativeCrash": True or False, # If a native process other than the app crashed. 5234 }, 5235 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 5236 # 5237 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 5238 # 5239 # Optional 5240 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 5241 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 5242 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 5243 "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. 5244 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 5245 }, 5246 "summary": "A String", # The simplest way to interpret a result. 5247 # 5248 # Required 5249 }, 5250 "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. 5251 # 5252 # 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. 5253 # 5254 # PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. 5255 # 5256 # - In response: present if previously set. - In create request: optional - In update request: optional 5257 # 5258 # # Examples 5259 # 5260 # Example 1: Compute Duration from two Timestamps in pseudo code. 5261 # 5262 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 5263 # 5264 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 5265 # 5266 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 5267 # 5268 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 5269 # 5270 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 5271 # 5272 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 5273 # 5274 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 5275 # 5276 # Example 3: Compute Duration from datetime.timedelta in Python. 5277 # 5278 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 5279 # 5280 # # JSON Mapping 5281 # 5282 # 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". 5283 "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. 5284 "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 5285 }, 5286 "hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. 5287 # 5288 # - In response: always set - In create/update request: never set 5289 }</pre> 5290</div> 5291 5292</body></html>