Blame - docs/dyn/toolresults_v1beta3.projects.histories.executions.steps.html - platform/external/python/google-api-python-client

blob: e3c33637df5998b9f8394feb2b401417719a81c9 [file] [log] [blame]

Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1	<html><body>
				2	<style>
				3
				4	body, h1, h2, h3, div, span, p, pre, a {
				5	margin: 0;
				6	padding: 0;
				7	border: 0;
				8	font-weight: inherit;
				9	font-style: inherit;
				10	font-size: 100%;
				11	font-family: inherit;
				12	vertical-align: baseline;
				13	}
				14
				15	body {
				16	font-size: 13px;
				17	padding: 1em;
				18	}
				19
				20	h1 {
				21	font-size: 26px;
				22	margin-bottom: 1em;
				23	}
				24
				25	h2 {
				26	font-size: 24px;
				27	margin-bottom: 1em;
				28	}
				29
				30	h3 {
				31	font-size: 20px;
				32	margin-bottom: 1em;
				33	margin-top: 1em;
				34	}
				35
				36	pre, code {
				37	line-height: 1.5;
				38	font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
				39	}
				40
				41	pre {
				42	margin-top: 0.5em;
				43	}
				44
				45	h1, h2, h3, p {
				46	font-family: Arial, sans serif;
				47	}
				48
				49	h1, h2, h3 {
				50	border-bottom: solid #CCC 1px;
				51	}
				52
				53	.toc_element {
				54	margin-top: 0.5em;
				55	}
				56
				57	.firstline {
				58	margin-left: 2 em;
				59	}
				60
				61	.method {
				62	margin-top: 1em;
				63	border: solid 1px #CCC;
				64	padding: 1em;
				65	background: #EEE;
				66	}
				67
				68	.details {
				69	font-weight: bold;
				70	font-size: 14px;
				71	}
				72
				73	</style>
				74
				75	<h1><a href="toolresults_v1beta3.html">Cloud Tool Results API</a> . <a href="toolresults_v1beta3.projects.html">projects</a> . <a href="toolresults_v1beta3.projects.histories.html">histories</a> . <a href="toolresults_v1beta3.projects.histories.executions.html">executions</a> . <a href="toolresults_v1beta3.projects.histories.executions.steps.html">steps</a></h1>
				76	<h2>Instance Methods</h2>
				77	<p class="toc_element">
Sai Cheemalapati	c30d2b5	2017-03-13 12:12:03 -0400	[diff] [blame]	78	<code><a href="toolresults_v1beta3.projects.histories.executions.steps.perfMetricsSummary.html">perfMetricsSummary()</a></code>
				79	</p>
				80	<p class="firstline">Returns the perfMetricsSummary Resource.</p>
				81
				82	<p class="toc_element">
				83	<code><a href="toolresults_v1beta3.projects.histories.executions.steps.perfSampleSeries.html">perfSampleSeries()</a></code>
				84	</p>
				85	<p class="firstline">Returns the perfSampleSeries Resource.</p>
				86
				87	<p class="toc_element">
Bu Sun Kim	715bd7f	2019-06-14 16:50:42 -0700	[diff] [blame]	88	<code><a href="toolresults_v1beta3.projects.histories.executions.steps.testCases.html">testCases()</a></code>
				89	</p>
				90	<p class="firstline">Returns the testCases Resource.</p>
				91
				92	<p class="toc_element">
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	93	<code><a href="toolresults_v1beta3.projects.histories.executions.steps.thumbnails.html">thumbnails()</a></code>
				94	</p>
				95	<p class="firstline">Returns the thumbnails Resource.</p>
				96
				97	<p class="toc_element">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	98	<code><a href="#accessibilityClusters">accessibilityClusters(name, locale=None, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	99	<p class="firstline">Lists accessibility clusters for a given Step May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if an argument in the request happens to be invalid; e.g. if the locale format is incorrect - NOT_FOUND - if the containing Step does not exist</p>
				100	<p class="toc_element">
				101	<code><a href="#close">close()</a></code></p>
				102	<p class="firstline">Close httplib2 connections.</p>
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	103	<p class="toc_element">
				104	<code><a href="#create">create(projectId, historyId, executionId, body=None, requestId=None, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	105	<p class="firstline">Creates a Step. The returned Step will have the id set. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist</p>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	106	<p class="toc_element">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	107	<code><a href="#get">get(projectId, historyId, executionId, stepId, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	108	<p class="firstline">Gets a Step. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the Step does not exist</p>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	109	<p class="toc_element">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	110	<code><a href="#getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	111	<p class="firstline">Retrieves a PerfMetricsSummary. May return any of the following error code(s): - NOT_FOUND - The specified PerfMetricsSummary does not exist</p>
Sai Cheemalapati	c30d2b5	2017-03-13 12:12:03 -0400	[diff] [blame]	112	<p class="toc_element">
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	113	<code><a href="#list">list(projectId, historyId, executionId, pageSize=None, pageToken=None, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	114	<p class="firstline">Lists Steps for a given Execution. The steps are sorted by creation_time in descending order. The step_id key will be used to order the steps with the same creation_time. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if an argument in the request happens to be invalid; e.g. if an attempt is made to list the children of a nonexistent Step - NOT_FOUND - if the containing Execution does not exist</p>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	115	<p class="toc_element">
				116	<code><a href="#list_next">list_next(previous_request, previous_response)</a></code></p>
				117	<p class="firstline">Retrieves the next page of results.</p>
				118	<p class="toc_element">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	119	<code><a href="#patch">patch(projectId, historyId, executionId, stepId, body=None, requestId=None, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	120	<p class="firstline">Updates an existing Step with the supplied partial entity. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal (e.g try to upload a duplicate xml file), if the updated step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist</p>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	121	<p class="toc_element">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	122	<code><a href="#publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body=None, x__xgafv=None)</a></code></p>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	123	<p class="firstline">Publish xml files to an existing Step. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal, e.g try to upload a duplicate xml file or a file too large. - NOT_FOUND - if the containing Execution does not exist</p>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	124	<h3>Method Details</h3>
				125	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	126	<code class="details" id="accessibilityClusters">accessibilityClusters(name, locale=None, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	127	<pre>Lists accessibility clusters for a given Step May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if an argument in the request happens to be invalid; e.g. if the locale format is incorrect - NOT_FOUND - if the containing Step does not exist
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	128
				129	Args:
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	130	name: string, A full resource name of the step. For example, projects/my-project/histories/bh.1234567890abcdef/executions/ 1234567890123456789/steps/bs.1234567890abcdef Required. (required)
				131	locale: string, The accepted format is the canonical Unicode format with hyphen as a delimiter. Language must be lowercase, Language Script - Capitalized, Region - UPPERCASE. See http://www.unicode.org/reports/tr35/#Unicode_locale_identifier for details. Required.
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	132	x__xgafv: string, V1 error format.
				133	Allowed values
				134	1 - v1 error format
				135	2 - v2 error format
				136
				137	Returns:
				138	An object of the form:
				139
				140	{ # Response message for AccessibilityService.ListStepAccessibilityClusters.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	141	"clusters": [ # A sequence of accessibility suggestions, grouped into clusters. Within the sequence, clusters that belong to the same SuggestionCategory should be adjacent. Within each category, clusters should be ordered by their SuggestionPriority (ERRORs first). The categories should be ordered by their highest priority cluster.
				142	{ # A set of similar suggestions that we suspect are closely related. This proto and most of the nested protos are branched from foxandcrown.prelaunchreport.service.SuggestionClusterProto, replacing PLR's dependencies with FTL's.
				143	"category": "A String", # Category in which these types of suggestions should appear. Always set.
				144	"suggestions": [ # A sequence of suggestions. All of the suggestions within a cluster must have the same SuggestionPriority and belong to the same SuggestionCategory. Suggestions with the same screenshot URL should be adjacent.
				145	{
				146	"helpUrl": "A String", # Reference to a help center article concerning this type of suggestion. Always set.
				147	"longMessage": { # IMPORTANT: It is unsafe to accept this message from an untrusted source, since it's trivial for an attacker to forge serialized messages that don't fulfill the type's safety contract -- for example, it could contain attacker controlled script. A system which receives a SafeHtmlProto implicitly trusts the producer of the SafeHtmlProto. So, it's generally safe to return this message in RPC responses, but generally unsafe to accept it in RPC requests. # Message, in the user's language, explaining the suggestion, which may contain markup. Always set.
				148	"privateDoNotAccessOrElseSafeHtmlWrappedValue": "A String", # IMPORTANT: Never set or read this field, even from tests, it is private. See documentation at the top of .proto file for programming language packages with which to create or read this message.
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	149	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	150	"priority": "A String", # Relative importance of a suggestion. Always set.
				151	"pseudoResourceId": "A String", # A somewhat human readable identifier of the source view, if it does not have a resource_name. This is a path within the accessibility hierarchy, an element with resource name; similar to an XPath.
				152	"region": { # A rectangular region. # Region within the screenshot that is relevant to this suggestion. Optional.
				153	"heightPx": 42, # The height, in pixels. Always set.
				154	"leftPx": 42, # The left side of the rectangle, in pixels. Always set.
				155	"topPx": 42, # The top of the rectangle, in pixels. Always set.
				156	"widthPx": 42, # The width, in pixels. Always set.
				157	},
				158	"resourceName": "A String", # Reference to a view element, identified by its resource name, if it has one.
				159	"screenId": "A String", # ID of the screen for the suggestion. It is used for getting the corresponding screenshot path. For example, screen_id "1" corresponds to "1.png" file in GCS. Always set.
				160	"secondaryPriority": 3.14, # Relative importance of a suggestion as compared with other suggestions that have the same priority and category. This is a meaningless value that can be used to order suggestions that are in the same category and have the same priority. The larger values have higher priority (i.e., are more important). Optional.
				161	"shortMessage": { # IMPORTANT: It is unsafe to accept this message from an untrusted source, since it's trivial for an attacker to forge serialized messages that don't fulfill the type's safety contract -- for example, it could contain attacker controlled script. A system which receives a SafeHtmlProto implicitly trusts the producer of the SafeHtmlProto. So, it's generally safe to return this message in RPC responses, but generally unsafe to accept it in RPC requests. # Concise message, in the user's language, representing the suggestion, which may contain markup. Always set.
				162	"privateDoNotAccessOrElseSafeHtmlWrappedValue": "A String", # IMPORTANT: Never set or read this field, even from tests, it is private. See documentation at the top of .proto file for programming language packages with which to create or read this message.
				163	},
				164	"title": "A String", # General title for the suggestion, in the user's language, without markup. Always set.
				165	},
				166	],
				167	},
				168	],
				169	"name": "A String", # A full resource name of the step. For example, projects/my-project/histories/bh.1234567890abcdef/executions/ 1234567890123456789/steps/bs.1234567890abcdef Always presents.
				170	}</pre>
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	171	</div>
				172
				173	<div class="method">
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	174	<code class="details" id="close">close()</code>
				175	<pre>Close httplib2 connections.</pre>
				176	</div>
				177
				178	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	179	<code class="details" id="create">create(projectId, historyId, executionId, body=None, requestId=None, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	180	<pre>Creates a Step. The returned Step will have the id set. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write to project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	181
				182	Args:
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	183	projectId: string, Required. A Project id. (required)
				184	historyId: string, Required. A History id. (required)
				185	executionId: string, Required. An Execution id. (required)
				186	body: object, The request body.
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	187	The object takes the form of:
				188
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	189	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	190	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	191	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	192	"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.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	193	},
				194	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	195	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	196	"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.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	197	},
				198	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	199	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				200	"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.
				201	"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
				202	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	203	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				204	{
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	205	"key": "A String",
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	206	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	207	},
				208	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	209	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	210	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				211	{
				212	"key": "A String",
				213	"value": "A String",
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	214	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	215	],
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	216	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				217	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				218	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				219	"individualOutcome": [ # Step Id and outcome of each individual step.
				220	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				221	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				222	"outcomeSummary": "A String",
				223	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
				224	"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.
				225	"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
				226	},
				227	"stepId": "A String",
				228	},
				229	],
				230	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				231	},
				232	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				233	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	234	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	235	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				236	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				237	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				238	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				239	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				240	"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.
				241	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				242	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				243	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				244	},
				245	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				246	"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.
				247	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				248	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				249	},
				250	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				251	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				252	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				253	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				254	},
				255	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				256	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				257	},
				258	"summary": "A String", # The simplest way to interpret a result. Required
				259	},
				260	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				261	"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.
				262	"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
				263	},
				264	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				265	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				266	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				267	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				268	{ # An issue detected occurring during a test execution.
				269	"category": "A String", # Category of issue. Required.
				270	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				271	"severity": "A String", # Severity of issue. Required.
				272	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				273	"exception": "A String", # The stack trace message. Required
				274	},
				275	"type": "A String", # Type of issue. Required.
				276	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				277	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				278	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				279	},
				280	},
				281	],
				282	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				283	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				284	"elapsedTime": { # 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. # Elapsed time of test suite.
				285	"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.
				286	"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
				287	},
				288	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				289	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				290	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				291	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				292	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				293	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				294	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				295	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				296	},
				297	},
				298	],
				299	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				300	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				301	"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.
				302	"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
				303	},
				304	},
				305	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				306	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				307	"A String",
				308	],
				309	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				310	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				311	},
				312	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				313	{ # A reference to a file.
				314	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				315	},
				316	],
				317	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				318	{ # A reference to a ToolExecution output file.
				319	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				320	"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.
				321	"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.
				322	},
				323	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				324	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				325	},
				326	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				327	"className": "A String", # The name of the class.
				328	"name": "A String", # The name of the test case. Required.
				329	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				330	},
				331	},
				332	],
				333	},
				334	},
				335	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				336	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				337	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				338	"A String",
				339	],
				340	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				341	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				342	},
				343	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				344	{ # A reference to a file.
				345	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				346	},
				347	],
				348	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				349	{ # A reference to a ToolExecution output file.
				350	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				351	"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.
				352	"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.
				353	},
				354	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				355	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				356	},
				357	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				358	"className": "A String", # The name of the class.
				359	"name": "A String", # The name of the test case. Required.
				360	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				361	},
				362	},
				363	],
				364	},
				365	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	366	}
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	367
				368	requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. Optional, but strongly recommended.
				369	x__xgafv: string, V1 error format.
				370	Allowed values
				371	1 - v1 error format
				372	2 - v2 error format
				373
				374	Returns:
				375	An object of the form:
				376
				377	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	378	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
				379	"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.
				380	"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.
				381	},
				382	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
				383	"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.
				384	"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.
				385	},
				386	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
				387	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				388	"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.
				389	"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
				390	},
				391	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				392	{
				393	"key": "A String",
				394	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	395	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	396	],
				397	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
				398	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				399	{
				400	"key": "A String",
				401	"value": "A String",
				402	},
				403	],
				404	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				405	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				406	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				407	"individualOutcome": [ # Step Id and outcome of each individual step.
				408	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				409	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				410	"outcomeSummary": "A String",
				411	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	412	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	413	"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
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	414	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	415	"stepId": "A String",
				416	},
				417	],
				418	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				419	},
				420	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				421	},
				422	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
				423	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				424	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				425	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				426	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				427	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				428	"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.
				429	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				430	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				431	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				432	},
				433	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				434	"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.
				435	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				436	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				437	},
				438	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				439	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				440	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				441	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				442	},
				443	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				444	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				445	},
				446	"summary": "A String", # The simplest way to interpret a result. Required
				447	},
				448	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				449	"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.
				450	"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
				451	},
				452	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				453	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				454	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				455	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				456	{ # An issue detected occurring during a test execution.
				457	"category": "A String", # Category of issue. Required.
				458	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				459	"severity": "A String", # Severity of issue. Required.
				460	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				461	"exception": "A String", # The stack trace message. Required
				462	},
				463	"type": "A String", # Type of issue. Required.
				464	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				465	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				466	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				467	},
				468	},
				469	],
				470	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				471	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				472	"elapsedTime": { # 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. # Elapsed time of test suite.
				473	"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.
				474	"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
				475	},
				476	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				477	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				478	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				479	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				480	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				481	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				482	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				483	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				484	},
				485	},
				486	],
				487	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				488	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				489	"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.
				490	"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
				491	},
				492	},
				493	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				494	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				495	"A String",
				496	],
				497	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				498	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				499	},
				500	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				501	{ # A reference to a file.
				502	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				503	},
				504	],
				505	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				506	{ # A reference to a ToolExecution output file.
				507	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				508	"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.
				509	"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.
				510	},
				511	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				512	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				513	},
				514	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				515	"className": "A String", # The name of the class.
				516	"name": "A String", # The name of the test case. Required.
				517	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				518	},
Bu Sun Kim	673ec5c	2020-11-16 11:05:03 -0700	[diff] [blame]	519	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	520	],
				521	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	522	},
				523	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				524	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				525	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				526	"A String",
				527	],
				528	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				529	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	530	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	531	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				532	{ # A reference to a file.
				533	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				534	},
				535	],
				536	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				537	{ # A reference to a ToolExecution output file.
				538	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				539	"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.
				540	"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.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	541	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	542	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	543	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				544	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	545	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				546	"className": "A String", # The name of the class.
				547	"name": "A String", # The name of the test case. Required.
				548	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	549	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	550	},
				551	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	552	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	553	},
				554	}</pre>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	555	</div>
				556
				557	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	558	<code class="details" id="get">get(projectId, historyId, executionId, stepId, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	559	<pre>Gets a Step. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - NOT_FOUND - if the Step does not exist
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	560
				561	Args:
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	562	projectId: string, A Project id. Required. (required)
				563	historyId: string, A History id. Required. (required)
				564	executionId: string, A Execution id. Required. (required)
				565	stepId: string, A Step id. Required. (required)
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	566	x__xgafv: string, V1 error format.
				567	Allowed values
				568	1 - v1 error format
				569	2 - v2 error format
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	570
				571	Returns:
				572	An object of the form:
				573
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	574	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	575	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
				576	"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.
				577	"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.
				578	},
				579	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
				580	"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.
				581	"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.
				582	},
				583	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
				584	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				585	"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.
				586	"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
				587	},
				588	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				589	{
				590	"key": "A String",
				591	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	592	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	593	],
				594	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
				595	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				596	{
				597	"key": "A String",
				598	"value": "A String",
				599	},
				600	],
				601	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				602	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				603	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				604	"individualOutcome": [ # Step Id and outcome of each individual step.
				605	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				606	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				607	"outcomeSummary": "A String",
				608	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	609	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	610	"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
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	611	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	612	"stepId": "A String",
				613	},
				614	],
				615	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				616	},
				617	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				618	},
				619	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
				620	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				621	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				622	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				623	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				624	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				625	"notInstalled": True or False, # If an app is not installed and thus no test can be run with the app. This might be caused by trying to run a test on an unsupported platform.
				626	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				627	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				628	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				629	},
				630	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				631	"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.
				632	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				633	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				634	},
				635	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				636	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				637	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				638	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				639	},
				640	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				641	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				642	},
				643	"summary": "A String", # The simplest way to interpret a result. Required
				644	},
				645	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				646	"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.
				647	"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
				648	},
				649	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				650	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				651	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				652	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				653	{ # An issue detected occurring during a test execution.
				654	"category": "A String", # Category of issue. Required.
				655	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				656	"severity": "A String", # Severity of issue. Required.
				657	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				658	"exception": "A String", # The stack trace message. Required
				659	},
				660	"type": "A String", # Type of issue. Required.
				661	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				662	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				663	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				664	},
				665	},
				666	],
				667	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				668	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				669	"elapsedTime": { # 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. # Elapsed time of test suite.
				670	"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.
				671	"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
				672	},
				673	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				674	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				675	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				676	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				677	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				678	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				679	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				680	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				681	},
				682	},
				683	],
				684	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				685	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				686	"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.
				687	"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
				688	},
				689	},
				690	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				691	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				692	"A String",
				693	],
				694	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				695	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				696	},
				697	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				698	{ # A reference to a file.
				699	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				700	},
				701	],
				702	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				703	{ # A reference to a ToolExecution output file.
				704	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				705	"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.
				706	"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.
				707	},
				708	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				709	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				710	},
				711	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				712	"className": "A String", # The name of the class.
				713	"name": "A String", # The name of the test case. Required.
				714	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				715	},
Bu Sun Kim	673ec5c	2020-11-16 11:05:03 -0700	[diff] [blame]	716	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	717	],
				718	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	719	},
				720	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				721	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				722	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				723	"A String",
				724	],
				725	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				726	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	727	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	728	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				729	{ # A reference to a file.
				730	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				731	},
				732	],
				733	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				734	{ # A reference to a ToolExecution output file.
				735	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				736	"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.
				737	"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.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	738	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	739	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	740	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				741	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	742	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				743	"className": "A String", # The name of the class.
				744	"name": "A String", # The name of the test case. Required.
				745	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	746	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	747	},
				748	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	749	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	750	},
				751	}</pre>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	752	</div>
				753
				754	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	755	<code class="details" id="getPerfMetricsSummary">getPerfMetricsSummary(projectId, historyId, executionId, stepId, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	756	<pre>Retrieves a PerfMetricsSummary. May return any of the following error code(s): - NOT_FOUND - The specified PerfMetricsSummary does not exist
Sai Cheemalapati	c30d2b5	2017-03-13 12:12:03 -0400	[diff] [blame]	757
				758	Args:
				759	projectId: string, The cloud project (required)
				760	historyId: string, A tool results history ID. (required)
				761	executionId: string, A tool results execution ID. (required)
				762	stepId: string, A tool results step ID. (required)
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	763	x__xgafv: string, V1 error format.
				764	Allowed values
				765	1 - v1 error format
				766	2 - v2 error format
Sai Cheemalapati	c30d2b5	2017-03-13 12:12:03 -0400	[diff] [blame]	767
				768	Returns:
				769	An object of the form:
				770
				771	{ # A summary of perf metrics collected and performance environment info
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	772	"appStartTime": {
				773	"fullyDrawnTime": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # Optional. The time from app start to reaching the developer-reported "fully drawn" time. This is only stored if the app includes a call to Activity.reportFullyDrawn(). See https://developer.android.com/topic/performance/launch-time.html#time-full
				774	"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.
				775	"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
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	776	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	777	"initialDisplayTime": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # The time from app start to the first displayed activity being drawn, as reported in Logcat. See https://developer.android.com/topic/performance/launch-time.html#time-initial
				778	"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.
				779	"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
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	780	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	781	},
				782	"executionId": "A String", # A tool results execution ID. @OutputOnly
				783	"graphicsStats": { # Graphics statistics for the App. The information is collected from 'adb shell dumpsys graphicsstats'. For more info see: https://developer.android.com/training/testing/performance.html Statistics will only be present for API 23+. # Graphics statistics for the entire run. Statistics are reset at the beginning of the run and collected at the end of the run.
				784	"buckets": [ # Histogram of frame render times. There should be 154 buckets ranging from [5ms, 6ms) to [4950ms, infinity)
				785	{
				786	"frameCount": "A String", # Number of frames in the bucket.
				787	"renderMillis": "A String", # Lower bound of render time in milliseconds.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	788	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	789	],
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	790	"highInputLatencyCount": "A String", # Total "high input latency" events.
				791	"jankyFrames": "A String", # Total frames with slow render time. Should be <= total_frames.
				792	"missedVsyncCount": "A String", # Total "missed vsync" events.
				793	"p50Millis": "A String", # 50th percentile frame render time in milliseconds.
				794	"p90Millis": "A String", # 90th percentile frame render time in milliseconds.
				795	"p95Millis": "A String", # 95th percentile frame render time in milliseconds.
				796	"p99Millis": "A String", # 99th percentile frame render time in milliseconds.
				797	"slowBitmapUploadCount": "A String", # Total "slow bitmap upload" events.
				798	"slowDrawCount": "A String", # Total "slow draw" events.
				799	"slowUiThreadCount": "A String", # Total "slow UI thread" events.
				800	"totalFrames": "A String", # Total frames rendered by package.
				801	},
				802	"historyId": "A String", # A tool results history ID. @OutputOnly
				803	"perfEnvironment": { # Encapsulates performance environment info # Describes the environment in which the performance metrics were collected
				804	"cpuInfo": { # CPU related environment info
				805	"cpuProcessor": "A String", # description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A'
				806	"cpuSpeedInGhz": 3.14, # the CPU clock speed in GHz
				807	"numberOfCores": 42, # the number of CPU cores
				808	},
				809	"memoryInfo": { # Memory related environment info
				810	"memoryCapInKibibyte": "A String", # Maximum memory that can be allocated to the process in KiB
				811	"memoryTotalInKibibyte": "A String", # Total memory available on the device in KiB
				812	},
				813	},
				814	"perfMetrics": [ # Set of resource collected
				815	"A String",
				816	],
				817	"projectId": "A String", # The cloud project @OutputOnly
				818	"stepId": "A String", # A tool results step ID. @OutputOnly
				819	}</pre>
Sai Cheemalapati	c30d2b5	2017-03-13 12:12:03 -0400	[diff] [blame]	820	</div>
				821
				822	<div class="method">
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	823	<code class="details" id="list">list(projectId, historyId, executionId, pageSize=None, pageToken=None, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	824	<pre>Lists Steps for a given Execution. The steps are sorted by creation_time in descending order. The step_id key will be used to order the steps with the same creation_time. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to read project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if an argument in the request happens to be invalid; e.g. if an attempt is made to list the children of a nonexistent Step - NOT_FOUND - if the containing Execution does not exist
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	825
				826	Args:
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	827	projectId: string, A Project id. Required. (required)
				828	historyId: string, A History id. Required. (required)
				829	executionId: string, A Execution id. Required. (required)
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	830	pageSize: integer, The maximum number of Steps to fetch. Default value: 25. The server will use this default if the field is not set or has a value of 0. Optional.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	831	pageToken: string, A continuation token to resume the query at the next item. Optional.
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	832	x__xgafv: string, V1 error format.
				833	Allowed values
				834	1 - v1 error format
				835	2 - v2 error format
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	836
				837	Returns:
				838	An object of the form:
				839
				840	{ # Response message for StepService.List.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	841	"nextPageToken": "A String", # A continuation token to resume the query at the next item. If set, indicates that there are more steps to read, by calling list again with this value in the page_token field.
				842	"steps": [ # Steps.
				843	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
				844	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
				845	"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.
				846	"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.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	847	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	848	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
				849	"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.
				850	"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.
				851	},
				852	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
				853	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				854	"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.
				855	"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
				856	},
				857	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				858	{
				859	"key": "A String",
				860	"value": "A String",
				861	},
				862	],
				863	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
				864	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				865	{
				866	"key": "A String",
				867	"value": "A String",
				868	},
				869	],
				870	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				871	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				872	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				873	"individualOutcome": [ # Step Id and outcome of each individual step.
				874	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				875	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				876	"outcomeSummary": "A String",
				877	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
				878	"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.
				879	"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
				880	},
				881	"stepId": "A String",
				882	},
				883	],
				884	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				885	},
				886	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				887	},
				888	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
				889	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				890	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				891	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				892	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				893	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				894	"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.
				895	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				896	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				897	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				898	},
				899	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				900	"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.
				901	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				902	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				903	},
				904	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				905	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				906	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				907	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				908	},
				909	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				910	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				911	},
				912	"summary": "A String", # The simplest way to interpret a result. Required
				913	},
				914	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				915	"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.
				916	"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
				917	},
				918	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				919	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				920	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				921	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				922	{ # An issue detected occurring during a test execution.
				923	"category": "A String", # Category of issue. Required.
				924	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				925	"severity": "A String", # Severity of issue. Required.
				926	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				927	"exception": "A String", # The stack trace message. Required
				928	},
				929	"type": "A String", # Type of issue. Required.
				930	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				931	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				932	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				933	},
				934	},
				935	],
				936	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				937	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				938	"elapsedTime": { # 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. # Elapsed time of test suite.
				939	"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.
				940	"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
				941	},
				942	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				943	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				944	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				945	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				946	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				947	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				948	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				949	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				950	},
				951	},
				952	],
				953	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				954	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				955	"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.
				956	"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
				957	},
				958	},
				959	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				960	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				961	"A String",
				962	],
				963	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				964	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				965	},
				966	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				967	{ # A reference to a file.
				968	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				969	},
				970	],
				971	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				972	{ # A reference to a ToolExecution output file.
				973	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				974	"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.
				975	"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.
				976	},
				977	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				978	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				979	},
				980	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				981	"className": "A String", # The name of the class.
				982	"name": "A String", # The name of the test case. Required.
				983	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				984	},
				985	},
				986	],
				987	},
				988	},
				989	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				990	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				991	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				992	"A String",
				993	],
				994	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				995	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				996	},
				997	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				998	{ # A reference to a file.
				999	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1000	},
				1001	],
				1002	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1003	{ # A reference to a ToolExecution output file.
				1004	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1005	"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.
				1006	"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.
				1007	},
				1008	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				1009	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1010	},
				1011	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1012	"className": "A String", # The name of the class.
				1013	"name": "A String", # The name of the test case. Required.
				1014	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				1015	},
				1016	},
				1017	],
				1018	},
				1019	},
				1020	},
				1021	],
				1022	}</pre>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1023	</div>
				1024
				1025	<div class="method">
				1026	<code class="details" id="list_next">list_next(previous_request, previous_response)</code>
				1027	<pre>Retrieves the next page of results.
				1028
				1029	Args:
				1030	previous_request: The request for the previous page. (required)
				1031	previous_response: The response from the request for the previous page. (required)
				1032
				1033	Returns:
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1034	A request object that you can call 'execute()' on to request the next
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1035	page. Returns None if there are no more items in the collection.
				1036	</pre>
				1037	</div>
				1038
				1039	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1040	<code class="details" id="patch">patch(projectId, historyId, executionId, stepId, body=None, requestId=None, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1041	<pre>Updates an existing Step with the supplied partial entity. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal (e.g try to upload a duplicate xml file), if the updated step is too large (more than 10Mib) - NOT_FOUND - if the containing Execution does not exist
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1042
				1043	Args:
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1044	projectId: string, A Project id. Required. (required)
				1045	historyId: string, A History id. Required. (required)
				1046	executionId: string, A Execution id. Required. (required)
				1047	stepId: string, A Step id. Required. (required)
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1048	body: object, The request body.
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1049	The object takes the form of:
				1050
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1051	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1052	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1053	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1054	"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.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1055	},
				1056	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1057	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1058	"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.
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1059	},
				1060	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1061	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				1062	"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.
				1063	"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
				1064	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1065	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				1066	{
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1067	"key": "A String",
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1068	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1069	},
				1070	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1071	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1072	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				1073	{
				1074	"key": "A String",
				1075	"value": "A String",
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	1076	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1077	],
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1078	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				1079	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1080	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				1081	"individualOutcome": [ # Step Id and outcome of each individual step.
				1082	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				1083	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1084	"outcomeSummary": "A String",
				1085	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
				1086	"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.
				1087	"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
				1088	},
				1089	"stepId": "A String",
				1090	},
				1091	],
				1092	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				1093	},
				1094	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				1095	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1096	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1097	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				1098	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				1099	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				1100	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				1101	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				1102	"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.
				1103	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				1104	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				1105	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				1106	},
				1107	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				1108	"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.
				1109	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				1110	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				1111	},
				1112	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				1113	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				1114	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				1115	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				1116	},
				1117	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				1118	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				1119	},
				1120	"summary": "A String", # The simplest way to interpret a result. Required
				1121	},
				1122	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				1123	"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.
				1124	"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
				1125	},
				1126	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				1127	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				1128	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				1129	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				1130	{ # An issue detected occurring during a test execution.
				1131	"category": "A String", # Category of issue. Required.
				1132	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				1133	"severity": "A String", # Severity of issue. Required.
				1134	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				1135	"exception": "A String", # The stack trace message. Required
				1136	},
				1137	"type": "A String", # Type of issue. Required.
				1138	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				1139	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				1140	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				1141	},
				1142	},
				1143	],
				1144	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				1145	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				1146	"elapsedTime": { # 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. # Elapsed time of test suite.
				1147	"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.
				1148	"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
				1149	},
				1150	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1151	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				1152	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				1153	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				1154	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1155	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1156	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				1157	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1158	},
				1159	},
				1160	],
				1161	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				1162	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				1163	"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.
				1164	"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
				1165	},
				1166	},
				1167	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				1168	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1169	"A String",
				1170	],
				1171	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1172	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				1173	},
				1174	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1175	{ # A reference to a file.
				1176	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1177	},
				1178	],
				1179	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1180	{ # A reference to a ToolExecution output file.
				1181	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1182	"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.
				1183	"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.
				1184	},
				1185	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				1186	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1187	},
				1188	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1189	"className": "A String", # The name of the class.
				1190	"name": "A String", # The name of the test case. Required.
				1191	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				1192	},
				1193	},
				1194	],
				1195	},
				1196	},
				1197	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				1198	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				1199	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1200	"A String",
				1201	],
				1202	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1203	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				1204	},
				1205	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1206	{ # A reference to a file.
				1207	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1208	},
				1209	],
				1210	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1211	{ # A reference to a ToolExecution output file.
				1212	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1213	"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.
				1214	"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.
				1215	},
				1216	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				1217	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1218	},
				1219	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1220	"className": "A String", # The name of the class.
				1221	"name": "A String", # The name of the test case. Required.
				1222	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				1223	},
				1224	},
				1225	],
				1226	},
				1227	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1228	}
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1229
				1230	requestId: string, A unique request ID for server to detect duplicated requests. For example, a UUID. Optional, but strongly recommended.
				1231	x__xgafv: string, V1 error format.
				1232	Allowed values
				1233	1 - v1 error format
				1234	2 - v2 error format
				1235
				1236	Returns:
				1237	An object of the form:
				1238
				1239	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1240	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
				1241	"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.
				1242	"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.
				1243	},
				1244	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
				1245	"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.
				1246	"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.
				1247	},
				1248	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
				1249	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				1250	"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.
				1251	"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
				1252	},
				1253	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				1254	{
				1255	"key": "A String",
				1256	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1257	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1258	],
				1259	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
				1260	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				1261	{
				1262	"key": "A String",
				1263	"value": "A String",
				1264	},
				1265	],
				1266	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				1267	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1268	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				1269	"individualOutcome": [ # Step Id and outcome of each individual step.
				1270	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				1271	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1272	"outcomeSummary": "A String",
				1273	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	1274	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1275	"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
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	1276	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1277	"stepId": "A String",
				1278	},
				1279	],
				1280	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				1281	},
				1282	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				1283	},
				1284	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
				1285	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				1286	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				1287	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				1288	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				1289	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				1290	"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.
				1291	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				1292	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				1293	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				1294	},
				1295	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				1296	"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.
				1297	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				1298	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				1299	},
				1300	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				1301	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				1302	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				1303	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				1304	},
				1305	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				1306	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				1307	},
				1308	"summary": "A String", # The simplest way to interpret a result. Required
				1309	},
				1310	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				1311	"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.
				1312	"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
				1313	},
				1314	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				1315	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				1316	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				1317	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				1318	{ # An issue detected occurring during a test execution.
				1319	"category": "A String", # Category of issue. Required.
				1320	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				1321	"severity": "A String", # Severity of issue. Required.
				1322	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				1323	"exception": "A String", # The stack trace message. Required
				1324	},
				1325	"type": "A String", # Type of issue. Required.
				1326	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				1327	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				1328	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				1329	},
				1330	},
				1331	],
				1332	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				1333	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				1334	"elapsedTime": { # 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. # Elapsed time of test suite.
				1335	"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.
				1336	"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
				1337	},
				1338	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1339	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				1340	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				1341	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				1342	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1343	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1344	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				1345	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1346	},
				1347	},
				1348	],
				1349	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				1350	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				1351	"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.
				1352	"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
				1353	},
				1354	},
				1355	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				1356	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1357	"A String",
				1358	],
				1359	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1360	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				1361	},
				1362	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1363	{ # A reference to a file.
				1364	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1365	},
				1366	],
				1367	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1368	{ # A reference to a ToolExecution output file.
				1369	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1370	"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.
				1371	"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.
				1372	},
				1373	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				1374	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1375	},
				1376	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1377	"className": "A String", # The name of the class.
				1378	"name": "A String", # The name of the test case. Required.
				1379	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				1380	},
Bu Sun Kim	673ec5c	2020-11-16 11:05:03 -0700	[diff] [blame]	1381	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1382	],
				1383	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1384	},
				1385	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				1386	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				1387	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1388	"A String",
				1389	],
				1390	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1391	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1392	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1393	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1394	{ # A reference to a file.
				1395	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1396	},
				1397	],
				1398	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1399	{ # A reference to a ToolExecution output file.
				1400	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1401	"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.
				1402	"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.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	1403	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1404	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1405	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1406	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1407	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1408	"className": "A String", # The name of the class.
				1409	"name": "A String", # The name of the test case. Required.
				1410	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	1411	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1412	},
				1413	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1414	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1415	},
				1416	}</pre>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1417	</div>
				1418
				1419	<div class="method">
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1420	<code class="details" id="publishXunitXmlFiles">publishXunitXmlFiles(projectId, historyId, executionId, stepId, body=None, x__xgafv=None)</code>
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1421	<pre>Publish xml files to an existing Step. May return any of the following canonical error codes: - PERMISSION_DENIED - if the user is not authorized to write project - INVALID_ARGUMENT - if the request is malformed - FAILED_PRECONDITION - if the requested state transition is illegal, e.g try to upload a duplicate xml file or a file too large. - NOT_FOUND - if the containing Execution does not exist
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1422
				1423	Args:
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1424	projectId: string, A Project id. Required. (required)
				1425	historyId: string, A History id. Required. (required)
				1426	executionId: string, A Execution id. Required. (required)
				1427	stepId: string, A Step id. Note: This step must include a TestExecutionStep. Required. (required)
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1428	body: object, The request body.
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1429	The object takes the form of:
				1430
				1431	{ # Request message for StepService.PublishXunitXmlFiles.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1432	"xunitXmlFiles": [ # URI of the Xunit XML files to publish. The maximum size of the file this reference is pointing to is 50MB. Required.
				1433	{ # A reference to a file.
				1434	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1435	},
				1436	],
				1437	}
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1438
Bu Sun Kim	d059ad8	2020-07-22 17:02:09 -0700	[diff] [blame]	1439	x__xgafv: string, V1 error format.
				1440	Allowed values
				1441	1 - v1 error format
				1442	2 - v2 error format
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1443
				1444	Returns:
				1445	An object of the form:
				1446
Dmitry Frenkel	3e17f89	2020-10-06 16:46:05 -0700	[diff] [blame]	1447	{ # A Step represents a single operation performed as part of Execution. A step can be used to represent the execution of a tool ( for example a test runner execution or an execution of a compiler). Steps can overlap (for instance two steps might have the same start time if some operations are done in parallel). Here is an example, let's consider that we have a continuous build is executing a test runner for each iteration. The workflow would look like: - user creates a Execution with id 1 - user creates an TestExecutionStep with id 100 for Execution 1 - user update TestExecutionStep with id 100 to add a raw xml log + the service parses the xml logs and returns a TestExecutionStep with updated TestResult(s). - user update the status of TestExecutionStep with id 100 to COMPLETE A Step can be updated until its state is set to COMPLETE at which points it becomes immutable. Next tag: 27
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1448	"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. 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). 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. # The time when the step status was set to complete. This value will be set automatically when state transitions to COMPLETE. - In response: set if the execution state is COMPLETE. - In create/update request: never set
				1449	"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.
				1450	"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.
				1451	},
				1452	"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. 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). 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. # The time when the step was created. - In response: always set - In create/update request: never set
				1453	"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.
				1454	"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.
				1455	},
				1456	"description": "A String", # A description of this tool For example: mvn clean package -D skipTests=true - In response: present if set by create/update request - In create/update request: optional
				1457	"deviceUsageDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How much the device resource is used to perform the test. This is the device usage used for billing purpose, which is different from the run_duration, for example, infrastructure failure won't be charged for device usage. PRECONDITION_FAILED will be returned if one attempts to set a device_usage on a step which already has this field set. - In response: present if previously set. - In create request: optional - In update request: optional
				1458	"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.
				1459	"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
				1460	},
				1461	"dimensionValue": [ # If the execution containing this step has any dimension_definition set, then this field allows the child to specify the values of the dimensions. The keys must exactly match the dimension_definition of the execution. For example, if the execution has `dimension_definition = ['attempt', 'device']` then a step must define values for those dimensions, eg. `dimension_value = ['attempt': '1', 'device': 'Nexus 6']` If a step does not participate in one dimension of the matrix, the value for that dimension should be empty string. For example, if one of the tests is executed by a runner which does not support retries, the step could have `dimension_value = ['attempt': '', 'device': 'Nexus 6']` If the step does not participate in any dimensions of the matrix, it may leave dimension_value unset. A PRECONDITION_FAILED will be returned if any of the keys do not exist in the dimension_definition of the execution. A PRECONDITION_FAILED will be returned if another step in this execution already has the same name and dimension_value, but differs on other data fields, for example, step field is different. A PRECONDITION_FAILED will be returned if dimension_value is set, and there is a dimension_definition in the execution which is not specified as one of the keys. - In response: present if set by create - In create request: optional - In update request: never set
				1462	{
				1463	"key": "A String",
				1464	"value": "A String",
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1465	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1466	],
				1467	"hasImages": True or False, # Whether any of the outputs of this step are images whose thumbnails can be fetched with ListThumbnails. - In response: always set - In create/update request: never set
				1468	"labels": [ # Arbitrary user-supplied key/value pairs that are associated with the step. Users are responsible for managing the key namespace such that keys don't accidentally collide. An INVALID_ARGUMENT will be returned if the number of labels exceeds 100 or if the length of any of the keys or values exceeds 100 characters. - In response: always set - In create request: optional - In update request: optional; any new key/value pair will be added to the map, and any new value for an existing key will update that key's value
				1469	{
				1470	"key": "A String",
				1471	"value": "A String",
				1472	},
				1473	],
				1474	"multiStep": { # Details when multiple steps are run with the same configuration as a group. # Details when multiple steps are run with the same configuration as a group. These details can be used identify which group this step is part of. It also identifies the groups 'primary step' which indexes all the group members. - In response: present if previously set. - In create request: optional, set iff this step was performed more than once. - In update request: optional
				1475	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1476	"primaryStep": { # Stores rollup test status of multiple steps that were run as a group and outcome of each individual step. # Present if it is a primary (original) step.
				1477	"individualOutcome": [ # Step Id and outcome of each individual step.
				1478	{ # Step Id and outcome of each individual step that was run as a group with other steps with the same configuration.
				1479	"multistepNumber": 42, # Unique int given to each step. Ranges from 0(inclusive) to total number of steps(exclusive). The primary step is 0.
				1480	"outcomeSummary": "A String",
				1481	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	1482	"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.
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1483	"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
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	1484	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1485	"stepId": "A String",
				1486	},
				1487	],
				1488	"rollUp": "A String", # Rollup test status of multiple steps that were run with the same configuration as a group.
				1489	},
				1490	"primaryStepId": "A String", # Step Id of the primary (original) step, which might be this step.
				1491	},
				1492	"name": "A String", # A short human-readable name to display in the UI. Maximum of 100 characters. For example: Clean build A PRECONDITION_FAILED will be returned upon creating a new step if it shares its name and dimension_value with an existing step. If two steps represent a similar action, but have different dimension values, they should share the same name. For instance, if the same set of tests is run on two different platforms, the two steps should have the same name. - In response: always set - In create request: always set - In update request: never set
				1493	"outcome": { # Interprets a result so that humans and machines can act on it. # Classification of the result, for example into SUCCESS or FAILURE - In response: present if set by create/update request - In create/update request: optional
				1494	"failureDetail": { # Details for an outcome with a FAILURE outcome summary. # More information about a FAILURE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not FAILURE. Optional
				1495	"crashed": True or False, # If the failure was severe because the system (app) under test crashed.
				1496	"deviceOutOfMemory": True or False, # If the device ran out of memory during a test, causing the test to crash.
				1497	"failedRoboscript": True or False, # If the Roboscript failed to complete successfully, e.g., because a Roboscript action or assertion failed or a Roboscript action could not be matched during the entire crawl.
				1498	"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.
				1499	"otherNativeCrash": True or False, # If a native process (including any other than the app) crashed.
				1500	"timedOut": True or False, # If the test overran some time limit, and that is why it failed.
				1501	"unableToCrawl": True or False, # If the robo was unable to crawl the app; perhaps because the app did not start.
				1502	},
				1503	"inconclusiveDetail": { # Details for an outcome with an INCONCLUSIVE outcome summary. # More information about an INCONCLUSIVE outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not INCONCLUSIVE. Optional
				1504	"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.
				1505	"hasErrorLogs": True or False, # If results are being provided to the user in certain cases of infrastructure failures
				1506	"infrastructureFailure": True or False, # If the test runner could not determine success or failure because the test depends on a component other than the system under test which failed. For example, a mobile test requires provisioning a device where the test executes, and that provisioning can fail.
				1507	},
				1508	"skippedDetail": { # Details for an outcome with a SKIPPED outcome summary. # More information about a SKIPPED outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SKIPPED. Optional
				1509	"incompatibleAppVersion": True or False, # If the App doesn't support the specific API level.
				1510	"incompatibleArchitecture": True or False, # If the App doesn't run on the specific architecture, for example, x86.
				1511	"incompatibleDevice": True or False, # If the requested OS version doesn't run on the specific device model.
				1512	},
				1513	"successDetail": { # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange # More information about a SUCCESS outcome. Returns INVALID_ARGUMENT if this field is set but the summary is not SUCCESS. Optional
				1514	"otherNativeCrash": True or False, # If a native process other than the app crashed.
				1515	},
				1516	"summary": "A String", # The simplest way to interpret a result. Required
				1517	},
				1518	"runDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took for this step to run. If unset, this is set to the difference between creation_time and completion_time when the step is set to the COMPLETE state. In some cases, it is appropriate to set this value separately: For instance, if a step is created, but the operation it represents is queued for a few minutes before it executes, it would be appropriate not to include the time spent queued in its run_duration. PRECONDITION_FAILED will be returned if one attempts to set a run_duration on a step which already has this field set. - In response: present if previously set; always present on COMPLETE step - In create request: optional - In update request: optional
				1519	"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.
				1520	"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
				1521	},
				1522	"state": "A String", # The initial state is IN_PROGRESS. The only legal state transitions are * IN_PROGRESS -> COMPLETE A PRECONDITION_FAILED will be returned if an invalid transition is requested. It is valid to create Step with a state set to COMPLETE. The state can only be set to COMPLETE once. A PRECONDITION_FAILED will be returned if the state is set to COMPLETE multiple times. - In response: always set - In create/update request: optional
				1523	"stepId": "A String", # A unique identifier within a Execution for this Step. Returns INVALID_ARGUMENT if this field is set or overwritten by the caller. - In response: always set - In create/update request: never set
				1524	"testExecutionStep": { # A step that represents running tests. It accepts ant-junit xml files which will be parsed into structured test results by the service. Xml file paths are updated in order to append more files, however they can't be deleted. Users can also add test results manually by using the test_result field. # An execution of a test runner.
				1525	"testIssues": [ # Issues observed during the test execution. For example, if the mobile app under test crashed during the test, the error message and the stack trace content can be recorded here to assist debugging. - In response: present if set by create or update - In create/update request: optional
				1526	{ # An issue detected occurring during a test execution.
				1527	"category": "A String", # Category of issue. Required.
				1528	"errorMessage": "A String", # A brief human-readable message describing the issue. Required.
				1529	"severity": "A String", # Severity of issue. Required.
				1530	"stackTrace": { # A stacktrace. # Deprecated in favor of stack trace fields inside specific warnings.
				1531	"exception": "A String", # The stack trace message. Required
				1532	},
				1533	"type": "A String", # Type of issue. Required.
				1534	"warning": { # `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message. Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type. Example 1: Pack and unpack a message in C++. Foo foo = ...; Any any; any.PackFrom(foo); ... if (any.UnpackTo(&foo)) { ... } Example 2: Pack and unpack a message in Java. Foo foo = ...; Any any = Any.pack(foo); ... if (any.is(Foo.class)) { foo = any.unpack(Foo.class); } Example 3: Pack and unpack a message in Python. foo = Foo(...) any = Any() any.Pack(foo) ... if any.Is(Foo.DESCRIPTOR): any.Unpack(foo) ... Example 4: Pack and unpack a message in Go foo := &pb.Foo{...} any, err := ptypes.MarshalAny(foo) ... foo := &pb.Foo{} if err := ptypes.UnmarshalAny(any, foo); err != nil { ... } The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z". # JSON The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example: package google.profile; message Person { string first_name = 1; string last_name = 2; } { "@type": "type.googleapis.com/google.profile.Person", "firstName": , "lastName": } If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message google.protobuf.Duration): { "@type": "type.googleapis.com/google.protobuf.Duration", "value": "1.212s" } # Warning message with additional details of the issue. Should always be a message from com.google.devtools.toolresults.v1.warnings
				1535	"typeUrl": "A String", # A URL/resource name that uniquely identifies the type of the serialized protocol buffer message. This string must contain at least one "/" character. The last segment of the URL's path must represent the fully qualified name of the type (as in `path/google.protobuf.Duration`). The name should be in a canonical form (e.g., leading "." is not accepted). In practice, teams usually precompile into the binary all types that they expect it to use in the context of Any. However, for URLs which use the scheme `http`, `https`, or no scheme, one can optionally set up a type server that maps type URLs to message definitions as follows: * If no scheme is provided, `https` is assumed. * An HTTP GET on the URL must yield a google.protobuf.Type value in binary format, or produce an error. * Applications are allowed to cache lookup results based on the URL, or have them precompiled into a binary to avoid any lookup. Therefore, binary compatibility needs to be preserved on changes to types. (Use versioned type names to manage breaking changes.) Note: this functionality is not currently available in the official protobuf release, and it is not used for type URLs beginning with type.googleapis.com. Schemes other than `http`, `https` (or the empty scheme) might be used with implementation specific semantics.
				1536	"value": "A String", # Must be a valid serialized protocol buffer of the above specified type.
				1537	},
				1538	},
				1539	],
				1540	"testSuiteOverviews": [ # List of test suite overview contents. This could be parsed from xUnit XML log by server, or uploaded directly by user. This references should only be called when test suites are fully parsed or uploaded. The maximum allowed number of test suite overviews per step is 1000. - In response: always set - In create request: optional - In update request: never (use publishXunitXmlFiles custom method instead)
				1541	{ # A summary of a test suite result either parsed from XML or uploaded directly by a user. Note: the API related comments are for StepService only. This message is also being used in ExecutionService in a read only mode for the corresponding step.
				1542	"elapsedTime": { # 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. # Elapsed time of test suite.
				1543	"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.
				1544	"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
				1545	},
				1546	"errorCount": 42, # Number of test cases in error, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1547	"failureCount": 42, # Number of failed test cases, typically set by the service by parsing the xml_source. May also be set by the user. - In create/response: always set - In update request: never
				1548	"flakyCount": 42, # Number of flaky test cases, set by the service by rolling up flaky test attempts. Present only for rollup test suite overview at environment level. A step cannot have flaky test cases.
				1549	"name": "A String", # The name of the test suite. - In create/response: always set - In update request: never
				1550	"skippedCount": 42, # Number of test cases not run, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1551	"totalCount": 42, # Number of test cases, typically set by the service by parsing the xml_source. - In create/response: always set - In update request: never
				1552	"xmlSource": { # A reference to a file. # If this test suite was parsed from XML, this is the URI where the original XML file is stored. Note: Multiple test suites can share the same xml_source Returns INVALID_ARGUMENT if the uri format is not supported. - In create/response: optional - In update request: never
				1553	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1554	},
				1555	},
				1556	],
				1557	"testTiming": { # Testing timing break down to know phases. # The timing break down of the test execution. - In response: present if set by create or update - In create/update request: optional
				1558	"testProcessDuration": { # A Duration represents a signed, fixed-length span of time represented as a count of seconds and fractions of seconds at nanosecond resolution. It is independent of any calendar and concepts like "day" or "month". It is related to Timestamp in that the difference between two Timestamp values is a Duration and it can be added or subtracted from a Timestamp. Range is approximately +-10,000 years. # How long it took to run the test process. - In response: present if previously set. - In create/update request: optional
				1559	"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.
				1560	"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
				1561	},
				1562	},
				1563	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # Represents the execution of the test runner. The exit code of this tool will be used to determine if the test passed. - In response: always set - In create/update request: optional
				1564	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1565	"A String",
				1566	],
				1567	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1568	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
				1569	},
				1570	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1571	{ # A reference to a file.
				1572	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1573	},
				1574	],
				1575	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1576	{ # A reference to a ToolExecution output file.
				1577	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1578	"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.
				1579	"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.
				1580	},
				1581	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
				1582	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1583	},
				1584	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1585	"className": "A String", # The name of the class.
				1586	"name": "A String", # The name of the test case. Required.
				1587	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
				1588	},
Bu Sun Kim	673ec5c	2020-11-16 11:05:03 -0700	[diff] [blame]	1589	},
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1590	],
				1591	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1592	},
				1593	"toolExecutionStep": { # Generic tool step to be used for binaries we do not explicitly support. For example: running cp to copy artifacts from one location to another. # An execution of a tool (used for steps we don't explicitly support).
				1594	"toolExecution": { # An execution of an arbitrary tool. It could be a test runner or a tool copying artifacts or deploying code. # A Tool execution. - In response: present if set by create/update request - In create/update request: optional
				1595	"commandLineArguments": [ # The full tokenized command line including the program name (equivalent to argv in a C program). - In response: present if set by create request - In create request: optional - In update request: never set
				1596	"A String",
				1597	],
				1598	"exitCode": { # Exit code from a tool execution. # Tool execution exit code. This field will be set once the tool has exited. - In response: present if set by create/update request - In create request: optional - In update request: optional, a FAILED_PRECONDITION error will be returned if an exit_code is already set.
				1599	"number": 42, # Tool execution exit code. A value of 0 means that the execution was successful. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1600	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1601	"toolLogs": [ # References to any plain text logs output the tool execution. This field can be set before the tool has exited in order to be able to have access to a live view of the logs while the tool is running. The maximum allowed number of tool logs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1602	{ # A reference to a file.
				1603	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1604	},
				1605	],
				1606	"toolOutputs": [ # References to opaque files of any format output by the tool execution. The maximum allowed number of tool outputs per step is 1000. - In response: present if set by create/update request - In create request: optional - In update request: optional, any value provided will be appended to the existing list
				1607	{ # A reference to a ToolExecution output file.
				1608	"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. 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). 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. # The creation time of the file. - In response: present if set by create/update request - In create/update request: optional
				1609	"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.
				1610	"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.
Yoshi Automation Bot	b6971b0	2020-11-26 17:16:03 -0800	[diff] [blame]	1611	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1612	"output": { # A reference to a file. # A FileReference to an output file. - In response: always set - In create/update request: always set
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1613	"fileUri": "A String", # The URI of a file stored in Google Cloud Storage. For example: http://storage.googleapis.com/mybucket/path/to/test.xml or in gsutil format: gs://mybucket/path/to/test.xml with version-specific info, gs://mybucket/path/to/test.xml#1360383693690000 An INVALID_ARGUMENT error will be returned if the URI format is not supported. - In response: always set - In create/update request: always set
				1614	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1615	"testCase": { # A reference to a test case. Test case references are canonically ordered lexicographically by these three factors: * First, by test_suite_name. * Second, by class_name. * Third, by name. # The test case to which this output file belongs. - In response: present if set by create/update request - In create/update request: optional
				1616	"className": "A String", # The name of the class.
				1617	"name": "A String", # The name of the test case. Required.
				1618	"testSuiteName": "A String", # The name of the test suite to which this test case belongs.
Yoshi Automation Bot	0d561ef	2020-11-25 07:50:41 -0800	[diff] [blame]	1619	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1620	},
				1621	],
Yoshi Automation Bot	0bf565c	2020-12-09 08:56:03 -0800	[diff] [blame]	1622	},
Yoshi Automation Bot	cc94ec8	2021-01-15 07:10:04 -0800	[diff] [blame]	1623	},
				1624	}</pre>
Jon Wayne Parrott	0a471d3	2016-05-19 10:54:38 -0700	[diff] [blame]	1625	</div>
				1626
				1627	</body></html>