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></h1> 76<h2>Instance Methods</h2> 77<p class="toc_element"> 78 <code><a href="toolresults_v1beta3.projects.histories.executions.clusters.html">clusters()</a></code> 79</p> 80<p class="firstline">Returns the clusters Resource.</p> 81 82<p class="toc_element"> 83 <code><a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps()</a></code> 84</p> 85<p class="firstline">Returns the steps Resource.</p> 86 87<p class="toc_element"> 88 <code><a href="#create">create(projectId, historyId, body, requestId=None)</a></code></p> 89<p class="firstline">Creates an Execution.</p> 90<p class="toc_element"> 91 <code><a href="#get">get(projectId, historyId, executionId)</a></code></p> 92<p class="firstline">Gets an Execution.</p> 93<p class="toc_element"> 94 <code><a href="#list">list(projectId, historyId, pageToken=None, pageSize=None)</a></code></p> 95<p class="firstline">Lists Executions for a given History.</p> 96<p class="toc_element"> 97 <code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p> 98<p class="firstline">Retrieves the next page of results.</p> 99<p class="toc_element"> 100 <code><a href="#patch">patch(projectId, historyId, executionId, body, requestId=None)</a></code></p> 101<p class="firstline">Updates an existing Execution with the supplied partial entity.</p> 102<h3>Method Details</h3> 103<div class="method"> 104 <code class="details" id="create">create(projectId, historyId, body, requestId=None)</code> 105 <pre>Creates an Execution. 106 107The returned Execution will have the id set. 108 109May return any of the following canonical error codes: 110 111- 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 112 113Args: 114 projectId: string, A Project id. 115 116Required. (required) 117 historyId: string, A History id. 118 119Required. (required) 120 body: object, The request body. (required) 121 The object takes the form of: 122 123{ # 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 124 # 125 # The maximum size of an execution message is 1 MiB. 126 # 127 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 128 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 129 # 130 # - In response: present if set by create - In create: optional - In update: never set 131 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 132 # 133 # - In response: present if set by create - In create: optional - In update: optional 134 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 135 "androidAppInfo": { # Android app information. # Information about the application under test. 136 "versionCode": "A String", # The internal version code of the app. Optional. 137 "packageName": "A String", # The package name of the app. Required. 138 "name": "A String", # The name of the app. Optional 139 "versionName": "A String", # The version name of the app. Optional. 140 }, 141 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 142 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 143 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 144 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 145 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 146 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 147 }, 148 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 149 # 150 # # Examples 151 # 152 # Example 1: Compute Duration from two Timestamps in pseudo code. 153 # 154 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 155 # 156 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 157 # 158 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 159 # 160 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 161 # 162 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 163 # 164 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 165 # 166 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 167 # 168 # Example 3: Compute Duration from datetime.timedelta in Python. 169 # 170 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 171 # 172 # # JSON Mapping 173 # 174 # 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". 175 "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. 176 "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 177 }, 178 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 179 # 180 # See for more information on types of Android tests. 181 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 182 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 183 "testPackageId": "A String", # The java package for the test to be executed. Required 184 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 185 # 186 # If empty, all targets in the module will be run. 187 "A String", 188 ], 189 }, 190 }, 191 }, 192 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 193 # 194 # This value will be set automatically when CreateExecution is called. 195 # 196 # - In response: always set - In create/update request: never set 197 # 198 # 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). 199 # 200 # 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. 201 # 202 # # Examples 203 # 204 # Example 1: Compute Timestamp from POSIX `time()`. 205 # 206 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 207 # 208 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 209 # 210 # struct timeval tv; gettimeofday(&tv, NULL); 211 # 212 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 213 # 214 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 215 # 216 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 217 # 218 # // 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)); 219 # 220 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 221 # 222 # long millis = System.currentTimeMillis(); 223 # 224 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 225 # 226 # 227 # 228 # Example 5: Compute Timestamp from current time in Python. 229 # 230 # timestamp = Timestamp() timestamp.GetCurrentTime() 231 # 232 # # JSON Mapping 233 # 234 # 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). 235 # 236 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 237 # 238 # 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. 239 "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. 240 "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. 241 }, 242 "executionId": "A String", # A unique identifier within a History for this Execution. 243 # 244 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 245 # 246 # - In response always set - In create/update request: never set 247 "state": "A String", # The initial state is IN_PROGRESS. 248 # 249 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 250 # 251 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 252 # 253 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 254 # 255 # 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. 256 # 257 # - In response always set - In create/update request: optional 258 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 259 # 260 # This value will be set automatically when state transitions to COMPLETE. 261 # 262 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 263 # 264 # 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). 265 # 266 # 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. 267 # 268 # # Examples 269 # 270 # Example 1: Compute Timestamp from POSIX `time()`. 271 # 272 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 273 # 274 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 275 # 276 # struct timeval tv; gettimeofday(&tv, NULL); 277 # 278 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 279 # 280 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 281 # 282 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 283 # 284 # // 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)); 285 # 286 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 287 # 288 # long millis = System.currentTimeMillis(); 289 # 290 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 291 # 292 # 293 # 294 # Example 5: Compute Timestamp from current time in Python. 295 # 296 # timestamp = Timestamp() timestamp.GetCurrentTime() 297 # 298 # # JSON Mapping 299 # 300 # 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). 301 # 302 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 303 # 304 # 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. 305 "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. 306 "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. 307 }, 308 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 309 # 310 # - In response: present if set by create/update request - In create/update request: optional 311 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 312 # 313 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 314 # 315 # Optional 316 "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. 317 # 318 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 319 "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. 320 }, 321 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 322 # 323 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 324 # 325 # Optional 326 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 327 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 328 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 329 }, 330 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 331 # 332 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 333 # 334 # Optional 335 "otherNativeCrash": True or False, # If a native process other than the app crashed. 336 }, 337 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 338 # 339 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 340 # 341 # Optional 342 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 343 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 344 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 345 "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. 346 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 347 }, 348 "summary": "A String", # The simplest way to interpret a result. 349 # 350 # Required 351 }, 352 } 353 354 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 355 356Optional, but strongly recommended. 357 358Returns: 359 An object of the form: 360 361 { # 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 362 # 363 # The maximum size of an execution message is 1 MiB. 364 # 365 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 366 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 367 # 368 # - In response: present if set by create - In create: optional - In update: never set 369 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 370 # 371 # - In response: present if set by create - In create: optional - In update: optional 372 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 373 "androidAppInfo": { # Android app information. # Information about the application under test. 374 "versionCode": "A String", # The internal version code of the app. Optional. 375 "packageName": "A String", # The package name of the app. Required. 376 "name": "A String", # The name of the app. Optional 377 "versionName": "A String", # The version name of the app. Optional. 378 }, 379 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 380 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 381 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 382 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 383 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 384 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 385 }, 386 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 387 # 388 # # Examples 389 # 390 # Example 1: Compute Duration from two Timestamps in pseudo code. 391 # 392 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 393 # 394 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 395 # 396 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 397 # 398 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 399 # 400 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 401 # 402 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 403 # 404 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 405 # 406 # Example 3: Compute Duration from datetime.timedelta in Python. 407 # 408 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 409 # 410 # # JSON Mapping 411 # 412 # 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". 413 "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. 414 "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 415 }, 416 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 417 # 418 # See for more information on types of Android tests. 419 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 420 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 421 "testPackageId": "A String", # The java package for the test to be executed. Required 422 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 423 # 424 # If empty, all targets in the module will be run. 425 "A String", 426 ], 427 }, 428 }, 429 }, 430 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 431 # 432 # This value will be set automatically when CreateExecution is called. 433 # 434 # - In response: always set - In create/update request: never set 435 # 436 # 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). 437 # 438 # 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. 439 # 440 # # Examples 441 # 442 # Example 1: Compute Timestamp from POSIX `time()`. 443 # 444 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 445 # 446 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 447 # 448 # struct timeval tv; gettimeofday(&tv, NULL); 449 # 450 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 451 # 452 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 453 # 454 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 455 # 456 # // 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)); 457 # 458 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 459 # 460 # long millis = System.currentTimeMillis(); 461 # 462 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 463 # 464 # 465 # 466 # Example 5: Compute Timestamp from current time in Python. 467 # 468 # timestamp = Timestamp() timestamp.GetCurrentTime() 469 # 470 # # JSON Mapping 471 # 472 # 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). 473 # 474 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 475 # 476 # 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. 477 "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. 478 "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. 479 }, 480 "executionId": "A String", # A unique identifier within a History for this Execution. 481 # 482 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 483 # 484 # - In response always set - In create/update request: never set 485 "state": "A String", # The initial state is IN_PROGRESS. 486 # 487 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 488 # 489 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 490 # 491 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 492 # 493 # 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. 494 # 495 # - In response always set - In create/update request: optional 496 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 497 # 498 # This value will be set automatically when state transitions to COMPLETE. 499 # 500 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 501 # 502 # 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). 503 # 504 # 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. 505 # 506 # # Examples 507 # 508 # Example 1: Compute Timestamp from POSIX `time()`. 509 # 510 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 511 # 512 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 513 # 514 # struct timeval tv; gettimeofday(&tv, NULL); 515 # 516 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 517 # 518 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 519 # 520 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 521 # 522 # // 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)); 523 # 524 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 525 # 526 # long millis = System.currentTimeMillis(); 527 # 528 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 529 # 530 # 531 # 532 # Example 5: Compute Timestamp from current time in Python. 533 # 534 # timestamp = Timestamp() timestamp.GetCurrentTime() 535 # 536 # # JSON Mapping 537 # 538 # 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). 539 # 540 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 541 # 542 # 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. 543 "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. 544 "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. 545 }, 546 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 547 # 548 # - In response: present if set by create/update request - In create/update request: optional 549 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 550 # 551 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 552 # 553 # Optional 554 "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. 555 # 556 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 557 "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. 558 }, 559 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 560 # 561 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 562 # 563 # Optional 564 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 565 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 566 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 567 }, 568 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 569 # 570 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 571 # 572 # Optional 573 "otherNativeCrash": True or False, # If a native process other than the app crashed. 574 }, 575 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 576 # 577 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 578 # 579 # Optional 580 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 581 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 582 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 583 "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. 584 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 585 }, 586 "summary": "A String", # The simplest way to interpret a result. 587 # 588 # Required 589 }, 590 }</pre> 591</div> 592 593<div class="method"> 594 <code class="details" id="get">get(projectId, historyId, executionId)</code> 595 <pre>Gets an Execution. 596 597May return any of the following canonical error codes: 598 599- 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 600 601Args: 602 projectId: string, A Project id. 603 604Required. (required) 605 historyId: string, A History id. 606 607Required. (required) 608 executionId: string, An Execution id. 609 610Required. (required) 611 612Returns: 613 An object of the form: 614 615 { # 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 616 # 617 # The maximum size of an execution message is 1 MiB. 618 # 619 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 620 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 621 # 622 # - In response: present if set by create - In create: optional - In update: never set 623 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 624 # 625 # - In response: present if set by create - In create: optional - In update: optional 626 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 627 "androidAppInfo": { # Android app information. # Information about the application under test. 628 "versionCode": "A String", # The internal version code of the app. Optional. 629 "packageName": "A String", # The package name of the app. Required. 630 "name": "A String", # The name of the app. Optional 631 "versionName": "A String", # The version name of the app. Optional. 632 }, 633 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 634 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 635 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 636 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 637 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 638 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 639 }, 640 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 641 # 642 # # Examples 643 # 644 # Example 1: Compute Duration from two Timestamps in pseudo code. 645 # 646 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 647 # 648 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 649 # 650 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 651 # 652 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 653 # 654 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 655 # 656 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 657 # 658 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 659 # 660 # Example 3: Compute Duration from datetime.timedelta in Python. 661 # 662 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 663 # 664 # # JSON Mapping 665 # 666 # 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". 667 "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. 668 "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 669 }, 670 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 671 # 672 # See for more information on types of Android tests. 673 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 674 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 675 "testPackageId": "A String", # The java package for the test to be executed. Required 676 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 677 # 678 # If empty, all targets in the module will be run. 679 "A String", 680 ], 681 }, 682 }, 683 }, 684 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 685 # 686 # This value will be set automatically when CreateExecution is called. 687 # 688 # - In response: always set - In create/update request: never set 689 # 690 # 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). 691 # 692 # 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. 693 # 694 # # Examples 695 # 696 # Example 1: Compute Timestamp from POSIX `time()`. 697 # 698 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 699 # 700 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 701 # 702 # struct timeval tv; gettimeofday(&tv, NULL); 703 # 704 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 705 # 706 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 707 # 708 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 709 # 710 # // 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)); 711 # 712 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 713 # 714 # long millis = System.currentTimeMillis(); 715 # 716 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 717 # 718 # 719 # 720 # Example 5: Compute Timestamp from current time in Python. 721 # 722 # timestamp = Timestamp() timestamp.GetCurrentTime() 723 # 724 # # JSON Mapping 725 # 726 # 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). 727 # 728 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 729 # 730 # 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. 731 "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. 732 "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. 733 }, 734 "executionId": "A String", # A unique identifier within a History for this Execution. 735 # 736 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 737 # 738 # - In response always set - In create/update request: never set 739 "state": "A String", # The initial state is IN_PROGRESS. 740 # 741 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 742 # 743 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 744 # 745 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 746 # 747 # 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. 748 # 749 # - In response always set - In create/update request: optional 750 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 751 # 752 # This value will be set automatically when state transitions to COMPLETE. 753 # 754 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 755 # 756 # 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). 757 # 758 # 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. 759 # 760 # # Examples 761 # 762 # Example 1: Compute Timestamp from POSIX `time()`. 763 # 764 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 765 # 766 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 767 # 768 # struct timeval tv; gettimeofday(&tv, NULL); 769 # 770 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 771 # 772 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 773 # 774 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 775 # 776 # // 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)); 777 # 778 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 779 # 780 # long millis = System.currentTimeMillis(); 781 # 782 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 783 # 784 # 785 # 786 # Example 5: Compute Timestamp from current time in Python. 787 # 788 # timestamp = Timestamp() timestamp.GetCurrentTime() 789 # 790 # # JSON Mapping 791 # 792 # 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). 793 # 794 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 795 # 796 # 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. 797 "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. 798 "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. 799 }, 800 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 801 # 802 # - In response: present if set by create/update request - In create/update request: optional 803 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 804 # 805 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 806 # 807 # Optional 808 "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. 809 # 810 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 811 "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. 812 }, 813 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 814 # 815 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 816 # 817 # Optional 818 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 819 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 820 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 821 }, 822 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 823 # 824 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 825 # 826 # Optional 827 "otherNativeCrash": True or False, # If a native process other than the app crashed. 828 }, 829 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 830 # 831 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 832 # 833 # Optional 834 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 835 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 836 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 837 "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. 838 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 839 }, 840 "summary": "A String", # The simplest way to interpret a result. 841 # 842 # Required 843 }, 844 }</pre> 845</div> 846 847<div class="method"> 848 <code class="details" id="list">list(projectId, historyId, pageToken=None, pageSize=None)</code> 849 <pre>Lists Executions for a given History. 850 851The 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. 852 853May return any of the following canonical error codes: 854 855- 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 856 857Args: 858 projectId: string, A Project id. 859 860Required. (required) 861 historyId: string, A History id. 862 863Required. (required) 864 pageToken: string, A continuation token to resume the query at the next item. 865 866Optional. 867 pageSize: integer, The maximum number of Executions to fetch. 868 869Default value: 25. The server will use this default if the field is not set or has a value of 0. 870 871Optional. 872 873Returns: 874 An object of the form: 875 876 { 877 "nextPageToken": "A String", # A continuation token to resume the query at the next item. 878 # 879 # Will only be set if there are more Executions to fetch. 880 "executions": [ # Executions. 881 # 882 # Always set. 883 { # 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 884 # 885 # The maximum size of an execution message is 1 MiB. 886 # 887 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 888 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 889 # 890 # - In response: present if set by create - In create: optional - In update: never set 891 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 892 # 893 # - In response: present if set by create - In create: optional - In update: optional 894 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 895 "androidAppInfo": { # Android app information. # Information about the application under test. 896 "versionCode": "A String", # The internal version code of the app. Optional. 897 "packageName": "A String", # The package name of the app. Required. 898 "name": "A String", # The name of the app. Optional 899 "versionName": "A String", # The version name of the app. Optional. 900 }, 901 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 902 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 903 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 904 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 905 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 906 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 907 }, 908 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 909 # 910 # # Examples 911 # 912 # Example 1: Compute Duration from two Timestamps in pseudo code. 913 # 914 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 915 # 916 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 917 # 918 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 919 # 920 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 921 # 922 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 923 # 924 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 925 # 926 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 927 # 928 # Example 3: Compute Duration from datetime.timedelta in Python. 929 # 930 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 931 # 932 # # JSON Mapping 933 # 934 # 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". 935 "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. 936 "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 937 }, 938 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 939 # 940 # See for more information on types of Android tests. 941 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 942 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 943 "testPackageId": "A String", # The java package for the test to be executed. Required 944 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 945 # 946 # If empty, all targets in the module will be run. 947 "A String", 948 ], 949 }, 950 }, 951 }, 952 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 953 # 954 # This value will be set automatically when CreateExecution is called. 955 # 956 # - In response: always set - In create/update request: never set 957 # 958 # 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). 959 # 960 # 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. 961 # 962 # # Examples 963 # 964 # Example 1: Compute Timestamp from POSIX `time()`. 965 # 966 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 967 # 968 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 969 # 970 # struct timeval tv; gettimeofday(&tv, NULL); 971 # 972 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 973 # 974 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 975 # 976 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 977 # 978 # // 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)); 979 # 980 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 981 # 982 # long millis = System.currentTimeMillis(); 983 # 984 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 985 # 986 # 987 # 988 # Example 5: Compute Timestamp from current time in Python. 989 # 990 # timestamp = Timestamp() timestamp.GetCurrentTime() 991 # 992 # # JSON Mapping 993 # 994 # 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). 995 # 996 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 997 # 998 # 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. 999 "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. 1000 "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. 1001 }, 1002 "executionId": "A String", # A unique identifier within a History for this Execution. 1003 # 1004 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1005 # 1006 # - In response always set - In create/update request: never set 1007 "state": "A String", # The initial state is IN_PROGRESS. 1008 # 1009 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 1010 # 1011 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 1012 # 1013 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 1014 # 1015 # 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. 1016 # 1017 # - In response always set - In create/update request: optional 1018 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 1019 # 1020 # This value will be set automatically when state transitions to COMPLETE. 1021 # 1022 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 1023 # 1024 # 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). 1025 # 1026 # 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. 1027 # 1028 # # Examples 1029 # 1030 # Example 1: Compute Timestamp from POSIX `time()`. 1031 # 1032 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1033 # 1034 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1035 # 1036 # struct timeval tv; gettimeofday(&tv, NULL); 1037 # 1038 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1039 # 1040 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1041 # 1042 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1043 # 1044 # // 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)); 1045 # 1046 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1047 # 1048 # long millis = System.currentTimeMillis(); 1049 # 1050 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1051 # 1052 # 1053 # 1054 # Example 5: Compute Timestamp from current time in Python. 1055 # 1056 # timestamp = Timestamp() timestamp.GetCurrentTime() 1057 # 1058 # # JSON Mapping 1059 # 1060 # 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). 1061 # 1062 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1063 # 1064 # 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. 1065 "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. 1066 "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. 1067 }, 1068 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 1069 # 1070 # - In response: present if set by create/update request - In create/update request: optional 1071 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 1072 # 1073 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 1074 # 1075 # Optional 1076 "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. 1077 # 1078 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 1079 "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. 1080 }, 1081 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 1082 # 1083 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 1084 # 1085 # Optional 1086 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1087 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1088 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1089 }, 1090 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 1091 # 1092 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1093 # 1094 # Optional 1095 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1096 }, 1097 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 1098 # 1099 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1100 # 1101 # Optional 1102 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 1103 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 1104 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1105 "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. 1106 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1107 }, 1108 "summary": "A String", # The simplest way to interpret a result. 1109 # 1110 # Required 1111 }, 1112 }, 1113 ], 1114 }</pre> 1115</div> 1116 1117<div class="method"> 1118 <code class="details" id="list_next">list_next(previous_request, previous_response)</code> 1119 <pre>Retrieves the next page of results. 1120 1121Args: 1122 previous_request: The request for the previous page. (required) 1123 previous_response: The response from the request for the previous page. (required) 1124 1125Returns: 1126 A request object that you can call 'execute()' on to request the next 1127 page. Returns None if there are no more items in the collection. 1128 </pre> 1129</div> 1130 1131<div class="method"> 1132 <code class="details" id="patch">patch(projectId, historyId, executionId, body, requestId=None)</code> 1133 <pre>Updates an existing Execution with the supplied partial entity. 1134 1135May return any of the following canonical error codes: 1136 1137- 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 1138 1139Args: 1140 projectId: string, A Project id. Required. (required) 1141 historyId: string, Required. (required) 1142 executionId: string, Required. (required) 1143 body: object, The request body. (required) 1144 The object takes the form of: 1145 1146{ # 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 1147 # 1148 # The maximum size of an execution message is 1 MiB. 1149 # 1150 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 1151 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 1152 # 1153 # - In response: present if set by create - In create: optional - In update: never set 1154 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 1155 # 1156 # - In response: present if set by create - In create: optional - In update: optional 1157 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 1158 "androidAppInfo": { # Android app information. # Information about the application under test. 1159 "versionCode": "A String", # The internal version code of the app. Optional. 1160 "packageName": "A String", # The package name of the app. Required. 1161 "name": "A String", # The name of the app. Optional 1162 "versionName": "A String", # The version name of the app. Optional. 1163 }, 1164 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 1165 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 1166 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 1167 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 1168 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 1169 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 1170 }, 1171 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 1172 # 1173 # # Examples 1174 # 1175 # Example 1: Compute Duration from two Timestamps in pseudo code. 1176 # 1177 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1178 # 1179 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1180 # 1181 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1182 # 1183 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1184 # 1185 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1186 # 1187 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1188 # 1189 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1190 # 1191 # Example 3: Compute Duration from datetime.timedelta in Python. 1192 # 1193 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1194 # 1195 # # JSON Mapping 1196 # 1197 # 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". 1198 "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. 1199 "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 1200 }, 1201 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 1202 # 1203 # See for more information on types of Android tests. 1204 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 1205 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 1206 "testPackageId": "A String", # The java package for the test to be executed. Required 1207 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 1208 # 1209 # If empty, all targets in the module will be run. 1210 "A String", 1211 ], 1212 }, 1213 }, 1214 }, 1215 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 1216 # 1217 # This value will be set automatically when CreateExecution is called. 1218 # 1219 # - In response: always set - In create/update request: never set 1220 # 1221 # 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). 1222 # 1223 # 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. 1224 # 1225 # # Examples 1226 # 1227 # Example 1: Compute Timestamp from POSIX `time()`. 1228 # 1229 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1230 # 1231 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1232 # 1233 # struct timeval tv; gettimeofday(&tv, NULL); 1234 # 1235 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1236 # 1237 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1238 # 1239 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1240 # 1241 # // 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)); 1242 # 1243 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1244 # 1245 # long millis = System.currentTimeMillis(); 1246 # 1247 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1248 # 1249 # 1250 # 1251 # Example 5: Compute Timestamp from current time in Python. 1252 # 1253 # timestamp = Timestamp() timestamp.GetCurrentTime() 1254 # 1255 # # JSON Mapping 1256 # 1257 # 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). 1258 # 1259 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1260 # 1261 # 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. 1262 "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. 1263 "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. 1264 }, 1265 "executionId": "A String", # A unique identifier within a History for this Execution. 1266 # 1267 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1268 # 1269 # - In response always set - In create/update request: never set 1270 "state": "A String", # The initial state is IN_PROGRESS. 1271 # 1272 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 1273 # 1274 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 1275 # 1276 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 1277 # 1278 # 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. 1279 # 1280 # - In response always set - In create/update request: optional 1281 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 1282 # 1283 # This value will be set automatically when state transitions to COMPLETE. 1284 # 1285 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 1286 # 1287 # 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). 1288 # 1289 # 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. 1290 # 1291 # # Examples 1292 # 1293 # Example 1: Compute Timestamp from POSIX `time()`. 1294 # 1295 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1296 # 1297 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1298 # 1299 # struct timeval tv; gettimeofday(&tv, NULL); 1300 # 1301 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1302 # 1303 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1304 # 1305 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1306 # 1307 # // 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)); 1308 # 1309 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1310 # 1311 # long millis = System.currentTimeMillis(); 1312 # 1313 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1314 # 1315 # 1316 # 1317 # Example 5: Compute Timestamp from current time in Python. 1318 # 1319 # timestamp = Timestamp() timestamp.GetCurrentTime() 1320 # 1321 # # JSON Mapping 1322 # 1323 # 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). 1324 # 1325 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1326 # 1327 # 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. 1328 "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. 1329 "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. 1330 }, 1331 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 1332 # 1333 # - In response: present if set by create/update request - In create/update request: optional 1334 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 1335 # 1336 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 1337 # 1338 # Optional 1339 "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. 1340 # 1341 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 1342 "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. 1343 }, 1344 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 1345 # 1346 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 1347 # 1348 # Optional 1349 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1350 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1351 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1352 }, 1353 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 1354 # 1355 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1356 # 1357 # Optional 1358 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1359 }, 1360 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 1361 # 1362 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1363 # 1364 # Optional 1365 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 1366 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 1367 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1368 "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. 1369 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1370 }, 1371 "summary": "A String", # The simplest way to interpret a result. 1372 # 1373 # Required 1374 }, 1375 } 1376 1377 requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. 1378 1379Optional, but strongly recommended. 1380 1381Returns: 1382 An object of the form: 1383 1384 { # 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 1385 # 1386 # The maximum size of an execution message is 1 MiB. 1387 # 1388 # An Execution can be updated until its state is set to COMPLETE at which point it becomes immutable. 1389 "testExecutionMatrixId": "A String", # TestExecution Matrix ID that the TestExecutionService uses. 1390 # 1391 # - In response: present if set by create - In create: optional - In update: never set 1392 "specification": { # The details about how to run the execution. # Lightweight information about execution request. 1393 # 1394 # - In response: present if set by create - In create: optional - In update: optional 1395 "androidTest": { # An Android mobile test specification. # An Android mobile test execution specification. 1396 "androidAppInfo": { # Android app information. # Information about the application under test. 1397 "versionCode": "A String", # The internal version code of the app. Optional. 1398 "packageName": "A String", # The package name of the app. Required. 1399 "name": "A String", # The name of the app. Optional 1400 "versionName": "A String", # The version name of the app. Optional. 1401 }, 1402 "androidRoboTest": { # A test of an android application that explores the application on a virtual or physical Android device, finding culprits and crashes as it goes. # An Android robo test. 1403 "appInitialActivity": "A String", # The initial activity that should be used to start the app. Optional 1404 "bootstrapPackageId": "A String", # The java package for the bootstrap. Optional 1405 "bootstrapRunnerClass": "A String", # The runner class for the bootstrap. Optional 1406 "maxDepth": 42, # The max depth of the traversal stack Robo can explore. Optional 1407 "maxSteps": 42, # The max number of steps/actions Robo can execute. Default is no limit (0). Optional 1408 }, 1409 "testTimeout": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Max time a test is allowed to run before it is automatically cancelled. 1410 # 1411 # # Examples 1412 # 1413 # Example 1: Compute Duration from two Timestamps in pseudo code. 1414 # 1415 # Timestamp start = ...; Timestamp end = ...; Duration duration = ...; 1416 # 1417 # duration.seconds = end.seconds - start.seconds; duration.nanos = end.nanos - start.nanos; 1418 # 1419 # if (duration.seconds 0) { duration.seconds += 1; duration.nanos -= 1000000000; } else if (durations.seconds > 0 && duration.nanos < 0) { duration.seconds -= 1; duration.nanos += 1000000000; } 1420 # 1421 # Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. 1422 # 1423 # Timestamp start = ...; Duration duration = ...; Timestamp end = ...; 1424 # 1425 # end.seconds = start.seconds + duration.seconds; end.nanos = start.nanos + duration.nanos; 1426 # 1427 # if (end.nanos = 1000000000) { end.seconds += 1; end.nanos -= 1000000000; } 1428 # 1429 # Example 3: Compute Duration from datetime.timedelta in Python. 1430 # 1431 # td = datetime.timedelta(days=3, minutes=10) duration = Duration() duration.FromTimedelta(td) 1432 # 1433 # # JSON Mapping 1434 # 1435 # 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". 1436 "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. 1437 "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 1438 }, 1439 "androidInstrumentationTest": { # A test of an Android application that can control an Android component independently of its normal lifecycle. # An Android instrumentation test. 1440 # 1441 # See for more information on types of Android tests. 1442 "useOrchestrator": True or False, # The flag indicates whether Android Test Orchestrator will be used to run test or not. 1443 "testRunnerClass": "A String", # The InstrumentationTestRunner class. Required 1444 "testPackageId": "A String", # The java package for the test to be executed. Required 1445 "testTargets": [ # Each target must be fully qualified with the package name or class name, in one of these formats: - "package package_name" - "class package_name.class_name" - "class package_name.class_name#method_name" 1446 # 1447 # If empty, all targets in the module will be run. 1448 "A String", 1449 ], 1450 }, 1451 }, 1452 }, 1453 "creationTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution was created. 1454 # 1455 # This value will be set automatically when CreateExecution is called. 1456 # 1457 # - In response: always set - In create/update request: never set 1458 # 1459 # 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). 1460 # 1461 # 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. 1462 # 1463 # # Examples 1464 # 1465 # Example 1: Compute Timestamp from POSIX `time()`. 1466 # 1467 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1468 # 1469 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1470 # 1471 # struct timeval tv; gettimeofday(&tv, NULL); 1472 # 1473 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1474 # 1475 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1476 # 1477 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1478 # 1479 # // 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)); 1480 # 1481 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1482 # 1483 # long millis = System.currentTimeMillis(); 1484 # 1485 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1486 # 1487 # 1488 # 1489 # Example 5: Compute Timestamp from current time in Python. 1490 # 1491 # timestamp = Timestamp() timestamp.GetCurrentTime() 1492 # 1493 # # JSON Mapping 1494 # 1495 # 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). 1496 # 1497 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1498 # 1499 # 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. 1500 "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. 1501 "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. 1502 }, 1503 "executionId": "A String", # A unique identifier within a History for this Execution. 1504 # 1505 # Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. 1506 # 1507 # - In response always set - In create/update request: never set 1508 "state": "A String", # The initial state is IN_PROGRESS. 1509 # 1510 # The only legal state transitions is from IN_PROGRESS to COMPLETE. 1511 # 1512 # A PRECONDITION_FAILED will be returned if an invalid transition is requested. 1513 # 1514 # The state can only be set to COMPLETE once. A FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple times. 1515 # 1516 # 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. 1517 # 1518 # - In response always set - In create/update request: optional 1519 "completionTime": { # A Timestamp represents a point in time independent of any time zone or local calendar, encoded as a count of seconds and fractions of seconds at nanosecond resolution. The count is relative to an epoch at UTC midnight on January 1, 1970, in the proleptic Gregorian calendar which extends the Gregorian calendar backwards to year one. # The time when the Execution status transitioned to COMPLETE. 1520 # 1521 # This value will be set automatically when state transitions to COMPLETE. 1522 # 1523 # - In response: set if the execution state is COMPLETE. - In create/update request: never set 1524 # 1525 # 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). 1526 # 1527 # 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. 1528 # 1529 # # Examples 1530 # 1531 # Example 1: Compute Timestamp from POSIX `time()`. 1532 # 1533 # Timestamp timestamp; timestamp.set_seconds(time(NULL)); timestamp.set_nanos(0); 1534 # 1535 # Example 2: Compute Timestamp from POSIX `gettimeofday()`. 1536 # 1537 # struct timeval tv; gettimeofday(&tv, NULL); 1538 # 1539 # Timestamp timestamp; timestamp.set_seconds(tv.tv_sec); timestamp.set_nanos(tv.tv_usec * 1000); 1540 # 1541 # Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. 1542 # 1543 # FILETIME ft; GetSystemTimeAsFileTime(&ft); UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; 1544 # 1545 # // 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)); 1546 # 1547 # Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. 1548 # 1549 # long millis = System.currentTimeMillis(); 1550 # 1551 # Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) .setNanos((int) ((millis % 1000) * 1000000)).build(); 1552 # 1553 # 1554 # 1555 # Example 5: Compute Timestamp from current time in Python. 1556 # 1557 # timestamp = Timestamp() timestamp.GetCurrentTime() 1558 # 1559 # # JSON Mapping 1560 # 1561 # 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). 1562 # 1563 # For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past 01:30 UTC on January 15, 2017. 1564 # 1565 # 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. 1566 "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. 1567 "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. 1568 }, 1569 "outcome": { # Interprets a result so that humans and machines can act on it. # Classify the result, for example into SUCCESS or FAILURE 1570 # 1571 # - In response: present if set by create/update request - In create/update request: optional 1572 "inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. 1573 # 1574 # Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. 1575 # 1576 # Optional 1577 "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. 1578 # 1579 # For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail. 1580 "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. 1581 }, 1582 "skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. 1583 # 1584 # Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. 1585 # 1586 # Optional 1587 "incompatibleAppVersion": True or False, # If the App doesn't support the specific API level. 1588 "incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86. 1589 "incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model. 1590 }, 1591 "successDetail": { # Details for an outcome with a SUCCESS outcome summary. # More information about a SUCCESS outcome. 1592 # 1593 # Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. 1594 # 1595 # Optional 1596 "otherNativeCrash": True or False, # If a native process other than the app crashed. 1597 }, 1598 "failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. 1599 # 1600 # Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. 1601 # 1602 # Optional 1603 "otherNativeCrash": True or False, # If a native process (including any other than the app) crashed. 1604 "crashed": True or False, # If the failure was severe because the system (app) under test crashed. 1605 "unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start. 1606 "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. 1607 "timedOut": True or False, # If the test overran some time limit, and that is why it failed. 1608 }, 1609 "summary": "A String", # The simplest way to interpret a result. 1610 # 1611 # Required 1612 }, 1613 }</pre> 1614</div> 1615 1616</body></html>