1 <html><body> 2 <style> 3 4 body, 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 15 body { 16 font-size: 13px; 17 padding: 1em; 18 } 19 20 h1 { 21 font-size: 26px; 22 margin-bottom: 1em; 23 } 24 25 h2 { 26 font-size: 24px; 27 margin-bottom: 1em; 28 } 29 30 h3 { 31 font-size: 20px; 32 margin-bottom: 1em; 33 margin-top: 1em; 34 } 35 36 pre, code { 37 line-height: 1.5; 38 font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace; 39 } 40 41 pre { 42 margin-top: 0.5em; 43 } 44 45 h1, h2, h3, p { 46 font-family: Arial, sans serif; 47 } 48 49 h1, 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></h1> 76 <h2>Instance Methods</h2> 77 <p class="toc_element"> 78 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps()</a></code> 79 </p> 80 <p class="firstline">Returns the steps Resource.</p> 81 82 <p class="toc_element"> 83 <code><a href="#create">create(projectId, historyId, body, requestId=None)</a></code></p> 84 <p class="firstline">Creates an Execution.</p> 85 <p class="toc_element"> 86 <code><a href="#get">get(projectId, historyId, executionId)</a></code></p> 87 <p class="firstline">Gets an Execution.</p> 88 <p class="toc_element"> 89 <code><a href="#list">list(projectId, historyId, pageToken=None, pageSize=None)</a></code></p> 90 <p class="firstline">Lists Histories for a given Project.</p> 91 <p class="toc_element"> 92 <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p> 93 <p class="firstline">Retrieves the next page of results.</p> 94 <p class="toc_element"> 95 <code><a href="#patch">patch(projectId, historyId, executionId, body, requestId=None)</a></code></p> 96 <p class="firstline">Updates an existing Execution with the supplied partial entity.</p> 97 <h3>Method Details</h3> 98 <div class="method"> 99 <code class="details" id="create">create(projectId, historyId, body, requestId=None)</code> 100 <pre>Creates an Execution. 101 102 The returned Execution will have the id set. 103 104 May return any of the following canonical error codes: 105 106 - PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the containing History does not exist 107 108 Args: 109 projectId: string, A Project id. 110 111 Required. (required) 112 historyId: string, A History id. 113 114 Required. (required) 115 body: object, The request body. (required) 116 The object takes the form of: 117 118 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 119 # 120 # The maximum size of an execution message is 1 MiB. 121 # 122 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 123 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 124 # 125 # - In response: present if set by create - In create: optional - In update: never set 126 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 127 # 128 # This value will be set automatically when CreateExecution is called. 129 # 130 # - In response: always set - In create/update request: never set 131 # 132 # # Examples 133 # 134 # Example 1: Compute Timestamp from POSIX `time()`. 135 # 136 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 137 # 138 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 139 # 140 # struct timeval tv; gettimeofday(&tv, NULL); 141 # 142 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 143 # 144 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 145 # 146 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 147 # 148 # // 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)); 149 # 150 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 151 # 152 # long millis = System.currentTimeMillis(); 153 # 154 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 155 # 156 # 157 # 158 # Example 5: Compute Timestamp from current time in Python. 159 # 160 # timestamp = Timestamp() timestamp.GetCurrentTime() 161 # 162 # # JSON Mapping 163 # 164 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 165 # 166 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 167 # 168 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 169 "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. 170 "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. 171 }, 172 "state": "A String", # The initial state is IN_PROGRESS. 173 # 174 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 175 # 176 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 177 # 178 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 179 # 180 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 181 # 182 # - In response always set - In create/update request: optional 183 "executionId": "A String", # A unique identifier within a History for this Execution. 184 # 185 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 186 # 187 # - In response always set - In create/update request: never set 188 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 189 # 190 # This value will be set automatically when state transitions to COMPLETE. 191 # 192 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 193 # 194 # # Examples 195 # 196 # Example 1: Compute Timestamp from POSIX `time()`. 197 # 198 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 199 # 200 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 201 # 202 # struct timeval tv; gettimeofday(&tv, NULL); 203 # 204 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 205 # 206 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 207 # 208 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 209 # 210 # // 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)); 211 # 212 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 213 # 214 # long millis = System.currentTimeMillis(); 215 # 216 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 217 # 218 # 219 # 220 # Example 5: Compute Timestamp from current time in Python. 221 # 222 # timestamp = Timestamp() timestamp.GetCurrentTime() 223 # 224 # # JSON Mapping 225 # 226 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 227 # 228 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 229 # 230 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 231 "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. 232 "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. 233 }, 234 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 235 # 236 # - In response: present if set by create/update request - In create/update request: optional 237 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 238 # 239 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 240 # 241 # Optional 242 "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. 243 # 244 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 245 "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. 246 }, 247 "skippedDetail": { # More information about a SKIPPED outcome. 248 # 249 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 250 # 251 # Optional 252 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 253 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 254 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 255 }, 256 "successDetail": { # More information about a SUCCESS outcome. 257 # 258 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 259 # 260 # Optional 261 "otherNativeCrash": True or False, # If a native process other than the app crashed. 262 }, 263 "failureDetail": { # More information about a FAILURE outcome. 264 # 265 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 266 # 267 # Optional 268 "otherNativeCrash": True or False, # If a native process other than the app crashed. 269 "crashed": True or False, # If the failure was severe because the system under test crashed. 270 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 271 "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. 272 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 273 }, 274 "summary": "A String", # The simplest way to interpret a result. 275 # 276 # Required 277 }, 278 } 279 280 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 281 282 Optional, but strongly recommended. 283 284 Returns: 285 An object of the form: 286 287 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 288 # 289 # The maximum size of an execution message is 1 MiB. 290 # 291 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 292 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 293 # 294 # - In response: present if set by create - In create: optional - In update: never set 295 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 296 # 297 # This value will be set automatically when CreateExecution is called. 298 # 299 # - In response: always set - In create/update request: never set 300 # 301 # # Examples 302 # 303 # Example 1: Compute Timestamp from POSIX `time()`. 304 # 305 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 306 # 307 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 308 # 309 # struct timeval tv; gettimeofday(&tv, NULL); 310 # 311 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 312 # 313 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 314 # 315 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 316 # 317 # // 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)); 318 # 319 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 320 # 321 # long millis = System.currentTimeMillis(); 322 # 323 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 324 # 325 # 326 # 327 # Example 5: Compute Timestamp from current time in Python. 328 # 329 # timestamp = Timestamp() timestamp.GetCurrentTime() 330 # 331 # # JSON Mapping 332 # 333 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 334 # 335 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 336 # 337 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 338 "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. 339 "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. 340 }, 341 "state": "A String", # The initial state is IN_PROGRESS. 342 # 343 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 344 # 345 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 346 # 347 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 348 # 349 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 350 # 351 # - In response always set - In create/update request: optional 352 "executionId": "A String", # A unique identifier within a History for this Execution. 353 # 354 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 355 # 356 # - In response always set - In create/update request: never set 357 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 358 # 359 # This value will be set automatically when state transitions to COMPLETE. 360 # 361 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 362 # 363 # # Examples 364 # 365 # Example 1: Compute Timestamp from POSIX `time()`. 366 # 367 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 368 # 369 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 370 # 371 # struct timeval tv; gettimeofday(&tv, NULL); 372 # 373 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 374 # 375 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 376 # 377 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 378 # 379 # // 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)); 380 # 381 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 382 # 383 # long millis = System.currentTimeMillis(); 384 # 385 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 386 # 387 # 388 # 389 # Example 5: Compute Timestamp from current time in Python. 390 # 391 # timestamp = Timestamp() timestamp.GetCurrentTime() 392 # 393 # # JSON Mapping 394 # 395 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 396 # 397 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 398 # 399 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 400 "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. 401 "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. 402 }, 403 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 404 # 405 # - In response: present if set by create/update request - In create/update request: optional 406 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 407 # 408 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 409 # 410 # Optional 411 "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. 412 # 413 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 414 "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. 415 }, 416 "skippedDetail": { # More information about a SKIPPED outcome. 417 # 418 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 419 # 420 # Optional 421 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 422 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 423 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 424 }, 425 "successDetail": { # More information about a SUCCESS outcome. 426 # 427 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 428 # 429 # Optional 430 "otherNativeCrash": True or False, # If a native process other than the app crashed. 431 }, 432 "failureDetail": { # More information about a FAILURE outcome. 433 # 434 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 435 # 436 # Optional 437 "otherNativeCrash": True or False, # If a native process other than the app crashed. 438 "crashed": True or False, # If the failure was severe because the system under test crashed. 439 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 440 "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. 441 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 442 }, 443 "summary": "A String", # The simplest way to interpret a result. 444 # 445 # Required 446 }, 447 }</pre> 448 </div> 449 450 <div class="method"> 451 <code class="details" id="get">get(projectId, historyId, executionId)</code> 452 <pre>Gets an Execution. 453 454 May return any of the following canonical error codes: 455 456 - PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the Execution does not exist 457 458 Args: 459 projectId: string, A Project id. 460 461 Required. (required) 462 historyId: string, A History id. 463 464 Required. (required) 465 executionId: string, An Execution id. 466 467 Required. (required) 468 469 Returns: 470 An object of the form: 471 472 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 473 # 474 # The maximum size of an execution message is 1 MiB. 475 # 476 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 477 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 478 # 479 # - In response: present if set by create - In create: optional - In update: never set 480 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 481 # 482 # This value will be set automatically when CreateExecution is called. 483 # 484 # - In response: always set - In create/update request: never set 485 # 486 # # Examples 487 # 488 # Example 1: Compute Timestamp from POSIX `time()`. 489 # 490 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 491 # 492 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 493 # 494 # struct timeval tv; gettimeofday(&tv, NULL); 495 # 496 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 497 # 498 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 499 # 500 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 501 # 502 # // 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)); 503 # 504 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 505 # 506 # long millis = System.currentTimeMillis(); 507 # 508 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 509 # 510 # 511 # 512 # Example 5: Compute Timestamp from current time in Python. 513 # 514 # timestamp = Timestamp() timestamp.GetCurrentTime() 515 # 516 # # JSON Mapping 517 # 518 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 519 # 520 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 521 # 522 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 523 "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. 524 "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. 525 }, 526 "state": "A String", # The initial state is IN_PROGRESS. 527 # 528 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 529 # 530 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 531 # 532 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 533 # 534 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 535 # 536 # - In response always set - In create/update request: optional 537 "executionId": "A String", # A unique identifier within a History for this Execution. 538 # 539 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 540 # 541 # - In response always set - In create/update request: never set 542 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 543 # 544 # This value will be set automatically when state transitions to COMPLETE. 545 # 546 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 547 # 548 # # Examples 549 # 550 # Example 1: Compute Timestamp from POSIX `time()`. 551 # 552 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 553 # 554 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 555 # 556 # struct timeval tv; gettimeofday(&tv, NULL); 557 # 558 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 559 # 560 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 561 # 562 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 563 # 564 # // 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)); 565 # 566 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 567 # 568 # long millis = System.currentTimeMillis(); 569 # 570 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 571 # 572 # 573 # 574 # Example 5: Compute Timestamp from current time in Python. 575 # 576 # timestamp = Timestamp() timestamp.GetCurrentTime() 577 # 578 # # JSON Mapping 579 # 580 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 581 # 582 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 583 # 584 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 585 "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. 586 "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. 587 }, 588 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 589 # 590 # - In response: present if set by create/update request - In create/update request: optional 591 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 592 # 593 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 594 # 595 # Optional 596 "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. 597 # 598 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 599 "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. 600 }, 601 "skippedDetail": { # More information about a SKIPPED outcome. 602 # 603 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 604 # 605 # Optional 606 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 607 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 608 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 609 }, 610 "successDetail": { # More information about a SUCCESS outcome. 611 # 612 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 613 # 614 # Optional 615 "otherNativeCrash": True or False, # If a native process other than the app crashed. 616 }, 617 "failureDetail": { # More information about a FAILURE outcome. 618 # 619 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 620 # 621 # Optional 622 "otherNativeCrash": True or False, # If a native process other than the app crashed. 623 "crashed": True or False, # If the failure was severe because the system under test crashed. 624 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 625 "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. 626 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 627 }, 628 "summary": "A String", # The simplest way to interpret a result. 629 # 630 # Required 631 }, 632 }</pre> 633 </div> 634 635 <div class="method"> 636 <code class="details" id="list">list(projectId, historyId, pageToken=None, pageSize=None)</code> 637 <pre>Lists Histories for a given Project. 638 639 The executions are sorted by creation_time in descending order. The execution_id key will be used to order the executions with the same creation_time. 640 641 May return any of the following canonical error codes: 642 643 - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the containing History does not exist 644 645 Args: 646 projectId: string, A Project id. 647 648 Required. (required) 649 historyId: string, A History id. 650 651 Required. (required) 652 pageToken: string, A continuation token to resume the query at the next item. 653 654 Optional. 655 pageSize: integer, The maximum number of Executions to fetch. 656 657 Default value: 25. The server will use this default if the field is not set or has a value of 0. 658 659 Optional. 660 661 Returns: 662 An object of the form: 663 664 { 665 "nextPageToken": "A String", # A continuation token to resume the query at the next item. 666 # 667 # Will only be set if there are more Executions to fetch. 668 "executions": [ # Executions. 669 # 670 # Always set. 671 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 672 # 673 # The maximum size of an execution message is 1 MiB. 674 # 675 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 676 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 677 # 678 # - In response: present if set by create - In create: optional - In update: never set 679 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 680 # 681 # This value will be set automatically when CreateExecution is called. 682 # 683 # - In response: always set - In create/update request: never set 684 # 685 # # Examples 686 # 687 # Example 1: Compute Timestamp from POSIX `time()`. 688 # 689 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 690 # 691 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 692 # 693 # struct timeval tv; gettimeofday(&tv, NULL); 694 # 695 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 696 # 697 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 698 # 699 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 700 # 701 # // 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)); 702 # 703 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 704 # 705 # long millis = System.currentTimeMillis(); 706 # 707 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 708 # 709 # 710 # 711 # Example 5: Compute Timestamp from current time in Python. 712 # 713 # timestamp = Timestamp() timestamp.GetCurrentTime() 714 # 715 # # JSON Mapping 716 # 717 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 718 # 719 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 720 # 721 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 722 "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. 723 "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. 724 }, 725 "state": "A String", # The initial state is IN_PROGRESS. 726 # 727 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 728 # 729 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 730 # 731 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 732 # 733 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 734 # 735 # - In response always set - In create/update request: optional 736 "executionId": "A String", # A unique identifier within a History for this Execution. 737 # 738 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 739 # 740 # - In response always set - In create/update request: never set 741 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 742 # 743 # This value will be set automatically when state transitions to COMPLETE. 744 # 745 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 746 # 747 # # Examples 748 # 749 # Example 1: Compute Timestamp from POSIX `time()`. 750 # 751 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 752 # 753 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 754 # 755 # struct timeval tv; gettimeofday(&tv, NULL); 756 # 757 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 758 # 759 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 760 # 761 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 762 # 763 # // 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)); 764 # 765 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 766 # 767 # long millis = System.currentTimeMillis(); 768 # 769 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 770 # 771 # 772 # 773 # Example 5: Compute Timestamp from current time in Python. 774 # 775 # timestamp = Timestamp() timestamp.GetCurrentTime() 776 # 777 # # JSON Mapping 778 # 779 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 780 # 781 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 782 # 783 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 784 "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. 785 "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. 786 }, 787 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 788 # 789 # - In response: present if set by create/update request - In create/update request: optional 790 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 791 # 792 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 793 # 794 # Optional 795 "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. 796 # 797 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 798 "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. 799 }, 800 "skippedDetail": { # More information about a SKIPPED outcome. 801 # 802 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 803 # 804 # Optional 805 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 806 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 807 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 808 }, 809 "successDetail": { # More information about a SUCCESS outcome. 810 # 811 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 812 # 813 # Optional 814 "otherNativeCrash": True or False, # If a native process other than the app crashed. 815 }, 816 "failureDetail": { # More information about a FAILURE outcome. 817 # 818 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 819 # 820 # Optional 821 "otherNativeCrash": True or False, # If a native process other than the app crashed. 822 "crashed": True or False, # If the failure was severe because the system under test crashed. 823 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 824 "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. 825 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 826 }, 827 "summary": "A String", # The simplest way to interpret a result. 828 # 829 # Required 830 }, 831 }, 832 ], 833 }</pre> 834 </div> 835 836 <div class="method"> 837 <code class="details" id="list_next">list_next(previous_request, previous_response)</code> 838 <pre>Retrieves the next page of results. 839 840 Args: 841 previous_request: The request for the previous page. (required) 842 previous_response: The response from the request for the previous page. (required) 843 844 Returns: 845 A request object that you can call 'execute()' on to request the next 846 page. Returns None if there are no more items in the collection. 847 </pre> 848 </div> 849 850 <div class="method"> 851 <code class="details" id="patch">patch(projectId, historyId, executionId, body, requestId=None)</code> 852 <pre>Updates an existing Execution with the supplied partial entity. 853 854 May return any of the following canonical error codes: 855 856 - PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal - NOT_FOUND - if the containing History does not exist 857 858 Args: 859 projectId: string, A Project id. Required. (required) 860 historyId: string, Required. (required) 861 executionId: string, Required. (required) 862 body: object, The request body. (required) 863 The object takes the form of: 864 865 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 866 # 867 # The maximum size of an execution message is 1 MiB. 868 # 869 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 870 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 871 # 872 # - In response: present if set by create - In create: optional - In update: never set 873 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 874 # 875 # This value will be set automatically when CreateExecution is called. 876 # 877 # - In response: always set - In create/update request: never set 878 # 879 # # Examples 880 # 881 # Example 1: Compute Timestamp from POSIX `time()`. 882 # 883 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 884 # 885 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 886 # 887 # struct timeval tv; gettimeofday(&tv, NULL); 888 # 889 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 890 # 891 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 892 # 893 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 894 # 895 # // 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)); 896 # 897 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 898 # 899 # long millis = System.currentTimeMillis(); 900 # 901 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 902 # 903 # 904 # 905 # Example 5: Compute Timestamp from current time in Python. 906 # 907 # timestamp = Timestamp() timestamp.GetCurrentTime() 908 # 909 # # JSON Mapping 910 # 911 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 912 # 913 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 914 # 915 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 916 "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. 917 "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. 918 }, 919 "state": "A String", # The initial state is IN_PROGRESS. 920 # 921 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 922 # 923 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 924 # 925 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 926 # 927 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 928 # 929 # - In response always set - In create/update request: optional 930 "executionId": "A String", # A unique identifier within a History for this Execution. 931 # 932 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 933 # 934 # - In response always set - In create/update request: never set 935 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 936 # 937 # This value will be set automatically when state transitions to COMPLETE. 938 # 939 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 940 # 941 # # Examples 942 # 943 # Example 1: Compute Timestamp from POSIX `time()`. 944 # 945 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 946 # 947 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 948 # 949 # struct timeval tv; gettimeofday(&tv, NULL); 950 # 951 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 952 # 953 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 954 # 955 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 956 # 957 # // 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)); 958 # 959 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 960 # 961 # long millis = System.currentTimeMillis(); 962 # 963 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 964 # 965 # 966 # 967 # Example 5: Compute Timestamp from current time in Python. 968 # 969 # timestamp = Timestamp() timestamp.GetCurrentTime() 970 # 971 # # JSON Mapping 972 # 973 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 974 # 975 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 976 # 977 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 978 "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. 979 "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. 980 }, 981 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 982 # 983 # - In response: present if set by create/update request - In create/update request: optional 984 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 985 # 986 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 987 # 988 # Optional 989 "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. 990 # 991 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 992 "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. 993 }, 994 "skippedDetail": { # More information about a SKIPPED outcome. 995 # 996 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 997 # 998 # Optional 999 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1000 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1001 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1002 }, 1003 "successDetail": { # More information about a SUCCESS outcome. 1004 # 1005 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1006 # 1007 # Optional 1008 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1009 }, 1010 "failureDetail": { # More information about a FAILURE outcome. 1011 # 1012 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1013 # 1014 # Optional 1015 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1016 "crashed": True or False, # If the failure was severe because the system under test crashed. 1017 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1018 "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. 1019 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1020 }, 1021 "summary": "A String", # The simplest way to interpret a result. 1022 # 1023 # Required 1024 }, 1025 } 1026 1027 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 1028 1029 Optional, but strongly recommended. 1030 1031 Returns: 1032 An object of the form: 1033 1034 { # An Execution represents a collection of Steps. For instance, it could represent: - a mobile test executed across a range of device configurations - a jenkins job with a build step followed by a test step 1035 # 1036 # The maximum size of an execution message is 1 MiB. 1037 # 1038 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 1039 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the Test Service uses. 1040 # 1041 # - In response: present if set by create - In create: optional - In update: never set 1042 "creationTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution was created. 1043 # 1044 # This value will be set automatically when CreateExecution is called. 1045 # 1046 # - In response: always set - In create/update request: never set 1047 # 1048 # # Examples 1049 # 1050 # Example 1: Compute Timestamp from POSIX `time()`. 1051 # 1052 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1053 # 1054 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1055 # 1056 # struct timeval tv; gettimeofday(&tv, NULL); 1057 # 1058 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1059 # 1060 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1061 # 1062 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1063 # 1064 # // 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)); 1065 # 1066 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1067 # 1068 # long millis = System.currentTimeMillis(); 1069 # 1070 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1071 # 1072 # 1073 # 1074 # Example 5: Compute Timestamp from current time in Python. 1075 # 1076 # timestamp = Timestamp() timestamp.GetCurrentTime() 1077 # 1078 # # JSON Mapping 1079 # 1080 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 1081 # 1082 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1083 # 1084 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 1085 "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. 1086 "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. 1087 }, 1088 "state": "A String", # The initial state is IN_PROGRESS. 1089 # 1090 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 1091 # 1092 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 1093 # 1094 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 1095 # 1096 # If the state is set to COMPLETE, all the in-progress steps within the execution will be set as COMPLETE. If the outcome of the step is not set, the outcome will be set to INCONCLUSIVE. 1097 # 1098 # - In response always set - In create/update request: optional 1099 "executionId": "A String", # A unique identifier within a History for this Execution. 1100 # 1101 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1102 # 1103 # - In response always set - In create/update request: never set 1104 "completionTime": { # A Timestamp represents a point in time independent of any time zone or calendar, represented as seconds and fractions of seconds at nanosecond resolution in UTC Epoch time. It is encoded using the Proleptic Gregorian Calendar which extends the Gregorian calendar backwards to year one. It is encoded assuming all minutes are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By restricting to that range, we ensure that we can convert to and from RFC 3339 date strings. See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). # The time when the Execution status transitioned to COMPLETE. 1105 # 1106 # This value will be set automatically when state transitions to COMPLETE. 1107 # 1108 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 1109 # 1110 # # Examples 1111 # 1112 # Example 1: Compute Timestamp from POSIX `time()`. 1113 # 1114 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1115 # 1116 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1117 # 1118 # struct timeval tv; gettimeofday(&tv, NULL); 1119 # 1120 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1121 # 1122 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1123 # 1124 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1125 # 1126 # // 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)); 1127 # 1128 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1129 # 1130 # long millis = System.currentTimeMillis(); 1131 # 1132 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1133 # 1134 # 1135 # 1136 # Example 5: Compute Timestamp from current time in Python. 1137 # 1138 # timestamp = Timestamp() timestamp.GetCurrentTime() 1139 # 1140 # # JSON Mapping 1141 # 1142 # In JSON format, the Timestamp type is encoded as a string in the [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z" where {year} is always expressed using four digits while {month}, {day}, {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution), are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone is required, though only UTC (as indicated by "Z") is presently supported. 1143 # 1144 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1145 # 1146 # In JavaScript, one can convert a Date object to this format using the standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString] method. In Python, a standard `datetime.datetime` object can be converted to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use the Joda Time's [`ISODateTimeFormat.dateTime()`]( http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()) to obtain a formatter capable of generating timestamps in this format. 1147 "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. 1148 "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. 1149 }, 1150 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 1151 # 1152 # - In response: present if set by create/update request - In create/update request: optional 1153 "inconclusiveDetail": { # More information about an INCONCLUSIVE outcome. 1154 # 1155 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 1156 # 1157 # Optional 1158 "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. 1159 # 1160 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 1161 "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. 1162 }, 1163 "skippedDetail": { # More information about a SKIPPED outcome. 1164 # 1165 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 1166 # 1167 # Optional 1168 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1169 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1170 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1171 }, 1172 "successDetail": { # More information about a SUCCESS outcome. 1173 # 1174 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1175 # 1176 # Optional 1177 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1178 }, 1179 "failureDetail": { # More information about a FAILURE outcome. 1180 # 1181 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1182 # 1183 # Optional 1184 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1185 "crashed": True or False, # If the failure was severe because the system under test crashed. 1186 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1187 "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. 1188 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1189 }, 1190 "summary": "A String", # The simplest way to interpret a result. 1191 # 1192 # Required 1193 }, 1194 }</pre> 1195 </div> 1196 1197 </body></html>
