# Copyright 2015 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

require 'date'
require 'google/apis/core/base_service'
require 'google/apis/core/json_representation'
require 'google/apis/core/hashable'
require 'google/apis/errors'

module Google
  module Apis
    module ToolresultsV1beta3
      
      # Additional details for an ANR crash.
      class Anr
        include Google::Apis::Core::Hashable
      
        # A stacktrace.
        # Corresponds to the JSON property `stackTrace`
        # @return [Google::Apis::ToolresultsV1beta3::StackTrace]
        attr_accessor :stack_trace
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @stack_trace = args[:stack_trace] if args.key?(:stack_trace)
        end
      end
      
      # Android app information.
      class AndroidAppInfo
        include Google::Apis::Core::Hashable
      
        # The name of the app. Optional
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        # The package name of the app. Required.
        # Corresponds to the JSON property `packageName`
        # @return [String]
        attr_accessor :package_name
      
        # The internal version code of the app. Optional.
        # Corresponds to the JSON property `versionCode`
        # @return [String]
        attr_accessor :version_code
      
        # The version name of the app. Optional.
        # Corresponds to the JSON property `versionName`
        # @return [String]
        attr_accessor :version_name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @name = args[:name] if args.key?(:name)
          @package_name = args[:package_name] if args.key?(:package_name)
          @version_code = args[:version_code] if args.key?(:version_code)
          @version_name = args[:version_name] if args.key?(:version_name)
        end
      end
      
      # A test of an Android application that can control an Android component
      # independently of its normal lifecycle. See for more information on types of
      # Android tests.
      class AndroidInstrumentationTest
        include Google::Apis::Core::Hashable
      
        # The java package for the test to be executed. Required
        # Corresponds to the JSON property `testPackageId`
        # @return [String]
        attr_accessor :test_package_id
      
        # The InstrumentationTestRunner class. Required
        # Corresponds to the JSON property `testRunnerClass`
        # @return [String]
        attr_accessor :test_runner_class
      
        # Each target must be fully qualified with the package name or class name, in
        # one of these formats: - "package package_name" - "class package_name.
        # class_name" - "class package_name.class_name#method_name" If empty, all
        # targets in the module will be run.
        # Corresponds to the JSON property `testTargets`
        # @return [Array<String>]
        attr_accessor :test_targets
      
        # The flag indicates whether Android Test Orchestrator will be used to run test
        # or not.
        # Corresponds to the JSON property `useOrchestrator`
        # @return [Boolean]
        attr_accessor :use_orchestrator
        alias_method :use_orchestrator?, :use_orchestrator
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @test_package_id = args[:test_package_id] if args.key?(:test_package_id)
          @test_runner_class = args[:test_runner_class] if args.key?(:test_runner_class)
          @test_targets = args[:test_targets] if args.key?(:test_targets)
          @use_orchestrator = args[:use_orchestrator] if args.key?(:use_orchestrator)
        end
      end
      
      # A test of an android application that explores the application on a virtual or
      # physical Android device, finding culprits and crashes as it goes.
      class AndroidRoboTest
        include Google::Apis::Core::Hashable
      
        # The initial activity that should be used to start the app. Optional
        # Corresponds to the JSON property `appInitialActivity`
        # @return [String]
        attr_accessor :app_initial_activity
      
        # The java package for the bootstrap. Optional
        # Corresponds to the JSON property `bootstrapPackageId`
        # @return [String]
        attr_accessor :bootstrap_package_id
      
        # The runner class for the bootstrap. Optional
        # Corresponds to the JSON property `bootstrapRunnerClass`
        # @return [String]
        attr_accessor :bootstrap_runner_class
      
        # The max depth of the traversal stack Robo can explore. Optional
        # Corresponds to the JSON property `maxDepth`
        # @return [Fixnum]
        attr_accessor :max_depth
      
        # The max number of steps/actions Robo can execute. Default is no limit (0).
        # Optional
        # Corresponds to the JSON property `maxSteps`
        # @return [Fixnum]
        attr_accessor :max_steps
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @app_initial_activity = args[:app_initial_activity] if args.key?(:app_initial_activity)
          @bootstrap_package_id = args[:bootstrap_package_id] if args.key?(:bootstrap_package_id)
          @bootstrap_runner_class = args[:bootstrap_runner_class] if args.key?(:bootstrap_runner_class)
          @max_depth = args[:max_depth] if args.key?(:max_depth)
          @max_steps = args[:max_steps] if args.key?(:max_steps)
        end
      end
      
      # An Android mobile test specification.
      class AndroidTest
        include Google::Apis::Core::Hashable
      
        # Android app information.
        # Corresponds to the JSON property `androidAppInfo`
        # @return [Google::Apis::ToolresultsV1beta3::AndroidAppInfo]
        attr_accessor :android_app_info
      
        # A test of an Android application that can control an Android component
        # independently of its normal lifecycle. See for more information on types of
        # Android tests.
        # Corresponds to the JSON property `androidInstrumentationTest`
        # @return [Google::Apis::ToolresultsV1beta3::AndroidInstrumentationTest]
        attr_accessor :android_instrumentation_test
      
        # A test of an android application that explores the application on a virtual or
        # physical Android device, finding culprits and crashes as it goes.
        # Corresponds to the JSON property `androidRoboTest`
        # @return [Google::Apis::ToolresultsV1beta3::AndroidRoboTest]
        attr_accessor :android_robo_test
      
        # Test Loops are tests that can be launched by the app itself, determining when
        # to run by listening for an intent.
        # Corresponds to the JSON property `androidTestLoop`
        # @return [Google::Apis::ToolresultsV1beta3::AndroidTestLoop]
        attr_accessor :android_test_loop
      
        # 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.
        # Corresponds to the JSON property `testTimeout`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :test_timeout
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @android_app_info = args[:android_app_info] if args.key?(:android_app_info)
          @android_instrumentation_test = args[:android_instrumentation_test] if args.key?(:android_instrumentation_test)
          @android_robo_test = args[:android_robo_test] if args.key?(:android_robo_test)
          @android_test_loop = args[:android_test_loop] if args.key?(:android_test_loop)
          @test_timeout = args[:test_timeout] if args.key?(:test_timeout)
        end
      end
      
      # Test Loops are tests that can be launched by the app itself, determining when
      # to run by listening for an intent.
      class AndroidTestLoop
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # `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" `
      class Any
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `typeUrl`
        # @return [String]
        attr_accessor :type_url
      
        # Must be a valid serialized protocol buffer of the above specified type.
        # Corresponds to the JSON property `value`
        # NOTE: Values are automatically base64 encoded/decoded in the client library.
        # @return [String]
        attr_accessor :value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @type_url = args[:type_url] if args.key?(:type_url)
          @value = args[:value] if args.key?(:value)
        end
      end
      
      # 
      class AppStartTime
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `fullyDrawnTime`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :fully_drawn_time
      
        # 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.
        # Corresponds to the JSON property `initialDisplayTime`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :initial_display_time
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @fully_drawn_time = args[:fully_drawn_time] if args.key?(:fully_drawn_time)
          @initial_display_time = args[:initial_display_time] if args.key?(:initial_display_time)
        end
      end
      
      # A suggestion to use deep links for a Robo run.
      class AvailableDeepLinks
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Encapsulates the metadata for basic sample series represented by a line chart
      class BasicPerfSampleSeries
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `perfMetricType`
        # @return [String]
        attr_accessor :perf_metric_type
      
        # 
        # Corresponds to the JSON property `perfUnit`
        # @return [String]
        attr_accessor :perf_unit
      
        # 
        # Corresponds to the JSON property `sampleSeriesLabel`
        # @return [String]
        attr_accessor :sample_series_label
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @perf_metric_type = args[:perf_metric_type] if args.key?(:perf_metric_type)
          @perf_unit = args[:perf_unit] if args.key?(:perf_unit)
          @sample_series_label = args[:sample_series_label] if args.key?(:sample_series_label)
        end
      end
      
      # The request must provide up to a maximum of 5000 samples to be created; a
      # larger sample size will cause an INVALID_ARGUMENT error
      class BatchCreatePerfSamplesRequest
        include Google::Apis::Core::Hashable
      
        # The set of PerfSamples to create should not include existing timestamps
        # Corresponds to the JSON property `perfSamples`
        # @return [Array<Google::Apis::ToolresultsV1beta3::PerfSample>]
        attr_accessor :perf_samples
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @perf_samples = args[:perf_samples] if args.key?(:perf_samples)
        end
      end
      
      # 
      class BatchCreatePerfSamplesResponse
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `perfSamples`
        # @return [Array<Google::Apis::ToolresultsV1beta3::PerfSample>]
        attr_accessor :perf_samples
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @perf_samples = args[:perf_samples] if args.key?(:perf_samples)
        end
      end
      
      # A warning that Robo encountered a screen that was mostly blank; this may
      # indicate a problem with the app.
      class BlankScreen
        include Google::Apis::Core::Hashable
      
        # The screen id of the element
        # Corresponds to the JSON property `screenId`
        # @return [String]
        attr_accessor :screen_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @screen_id = args[:screen_id] if args.key?(:screen_id)
        end
      end
      
      # 
      class CpuInfo
        include Google::Apis::Core::Hashable
      
        # description of the device processor ie '1.8 GHz hexa core 64-bit ARMv8-A'
        # Corresponds to the JSON property `cpuProcessor`
        # @return [String]
        attr_accessor :cpu_processor
      
        # the CPU clock speed in GHz
        # Corresponds to the JSON property `cpuSpeedInGhz`
        # @return [Float]
        attr_accessor :cpu_speed_in_ghz
      
        # the number of CPU cores
        # Corresponds to the JSON property `numberOfCores`
        # @return [Fixnum]
        attr_accessor :number_of_cores
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @cpu_processor = args[:cpu_processor] if args.key?(:cpu_processor)
          @cpu_speed_in_ghz = args[:cpu_speed_in_ghz] if args.key?(:cpu_speed_in_ghz)
          @number_of_cores = args[:number_of_cores] if args.key?(:number_of_cores)
        end
      end
      
      # Crash dialog was detected during the test execution
      class CrashDialogError
        include Google::Apis::Core::Hashable
      
        # The name of the package that caused the dialog.
        # Corresponds to the JSON property `crashPackage`
        # @return [String]
        attr_accessor :crash_package
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @crash_package = args[:crash_package] if args.key?(:crash_package)
        end
      end
      
      # A warning that device ran out of memory
      class DeviceOutOfMemory
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # 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.
      class Duration
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `nanos`
        # @return [Fixnum]
        attr_accessor :nanos
      
        # 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
        # Corresponds to the JSON property `seconds`
        # @return [Fixnum]
        attr_accessor :seconds
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @nanos = args[:nanos] if args.key?(:nanos)
          @seconds = args[:seconds] if args.key?(:seconds)
        end
      end
      
      # Additional details about encountered login screens.
      class EncounteredLoginScreen
        include Google::Apis::Core::Hashable
      
        # Number of encountered distinct login screens.
        # Corresponds to the JSON property `distinctScreens`
        # @return [Fixnum]
        attr_accessor :distinct_screens
      
        # Subset of login screens.
        # Corresponds to the JSON property `screenIds`
        # @return [Array<String>]
        attr_accessor :screen_ids
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @distinct_screens = args[:distinct_screens] if args.key?(:distinct_screens)
          @screen_ids = args[:screen_ids] if args.key?(:screen_ids)
        end
      end
      
      # Additional details about encountered screens with elements that are not
      # Android UI widgets.
      class EncounteredNonAndroidUiWidgetScreen
        include Google::Apis::Core::Hashable
      
        # Number of encountered distinct screens with non Android UI widgets.
        # Corresponds to the JSON property `distinctScreens`
        # @return [Fixnum]
        attr_accessor :distinct_screens
      
        # Subset of screens which contain non Android UI widgets.
        # Corresponds to the JSON property `screenIds`
        # @return [Array<String>]
        attr_accessor :screen_ids
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @distinct_screens = args[:distinct_screens] if args.key?(:distinct_screens)
          @screen_ids = args[:screen_ids] if args.key?(:screen_ids)
        end
      end
      
      # An Environment represents the set of test runs (Steps) from the parent
      # Execution that are configured with the same set of dimensions (Model, Version,
      # Locale, and Orientation). Multiple such runs occur particularly because of
      # features like sharding (splitting up a test suite to run in parallel across
      # devices) and reruns (running a test multiple times to check for different
      # outcomes).
      class Environment
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `completionTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :completion_time
      
        # 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.
        # Corresponds to the JSON property `creationTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :creation_time
      
        # Dimension values describing the environment. Dimension values always consist
        # of "Model", "Version", "Locale", and "Orientation". - In response: always set -
        # In create request: always set - In update request: never set
        # Corresponds to the JSON property `dimensionValue`
        # @return [Array<Google::Apis::ToolresultsV1beta3::EnvironmentDimensionValueEntry>]
        attr_accessor :dimension_value
      
        # A short human-readable name to display in the UI. Maximum of 100 characters.
        # For example: Nexus 5, API 27.
        # Corresponds to the JSON property `displayName`
        # @return [String]
        attr_accessor :display_name
      
        # Output only. An Environment id.
        # Corresponds to the JSON property `environmentId`
        # @return [String]
        attr_accessor :environment_id
      
        # Merged test result for environment. If the environment has only one step (no
        # reruns or shards), then the merged result is the same as the step result. If
        # the environment has multiple shards and/or reruns, then the results of shards
        # and reruns that belong to the same environment are merged into one environment
        # result.
        # Corresponds to the JSON property `environmentResult`
        # @return [Google::Apis::ToolresultsV1beta3::MergedResult]
        attr_accessor :environment_result
      
        # Output only. An Execution id.
        # Corresponds to the JSON property `executionId`
        # @return [String]
        attr_accessor :execution_id
      
        # Output only. A History id.
        # Corresponds to the JSON property `historyId`
        # @return [String]
        attr_accessor :history_id
      
        # Output only. A Project id.
        # Corresponds to the JSON property `projectId`
        # @return [String]
        attr_accessor :project_id
      
        # The storage for test results.
        # Corresponds to the JSON property `resultsStorage`
        # @return [Google::Apis::ToolresultsV1beta3::ResultsStorage]
        attr_accessor :results_storage
      
        # Output only. Summaries of shards. Only one shard will present unless sharding
        # feature is enabled in TestExecutionService.
        # Corresponds to the JSON property `shardSummaries`
        # @return [Array<Google::Apis::ToolresultsV1beta3::ShardSummary>]
        attr_accessor :shard_summaries
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @completion_time = args[:completion_time] if args.key?(:completion_time)
          @creation_time = args[:creation_time] if args.key?(:creation_time)
          @dimension_value = args[:dimension_value] if args.key?(:dimension_value)
          @display_name = args[:display_name] if args.key?(:display_name)
          @environment_id = args[:environment_id] if args.key?(:environment_id)
          @environment_result = args[:environment_result] if args.key?(:environment_result)
          @execution_id = args[:execution_id] if args.key?(:execution_id)
          @history_id = args[:history_id] if args.key?(:history_id)
          @project_id = args[:project_id] if args.key?(:project_id)
          @results_storage = args[:results_storage] if args.key?(:results_storage)
          @shard_summaries = args[:shard_summaries] if args.key?(:shard_summaries)
        end
      end
      
      # 
      class EnvironmentDimensionValueEntry
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `key`
        # @return [String]
        attr_accessor :key
      
        # 
        # Corresponds to the JSON property `value`
        # @return [String]
        attr_accessor :value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @key = args[:key] if args.key?(:key)
          @value = args[:value] if args.key?(:value)
        end
      end
      
      # An Execution represents a collection of Steps. For instance, it could
      # represent: - a mobile test executed across a range of device configurations -
      # a jenkins job with a build step followed by a test step The maximum size of an
      # execution message is 1 MiB. An Execution can be updated until its state is set
      # to COMPLETE at which point it becomes immutable.
      class Execution
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `completionTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :completion_time
      
        # 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.
        # Corresponds to the JSON property `creationTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :creation_time
      
        # The dimensions along which different steps in this execution may vary. This
        # must remain fixed over the life of the execution. Returns INVALID_ARGUMENT if
        # this field is set in an update request. Returns INVALID_ARGUMENT if the same
        # name occurs in more than one dimension_definition. Returns INVALID_ARGUMENT if
        # the size of the list is over 100. - In response: present if set by create - In
        # create request: optional - In update request: never set
        # Corresponds to the JSON property `dimensionDefinitions`
        # @return [Array<Google::Apis::ToolresultsV1beta3::MatrixDimensionDefinition>]
        attr_accessor :dimension_definitions
      
        # A unique identifier within a History for this Execution. Returns
        # INVALID_ARGUMENT if this field is set or overwritten by the caller. - In
        # response always set - In create/update request: never set
        # Corresponds to the JSON property `executionId`
        # @return [String]
        attr_accessor :execution_id
      
        # Interprets a result so that humans and machines can act on it.
        # Corresponds to the JSON property `outcome`
        # @return [Google::Apis::ToolresultsV1beta3::Outcome]
        attr_accessor :outcome
      
        # The details about how to run the execution.
        # Corresponds to the JSON property `specification`
        # @return [Google::Apis::ToolresultsV1beta3::Specification]
        attr_accessor :specification
      
        # The initial state is IN_PROGRESS. The only legal state transitions is from
        # IN_PROGRESS to COMPLETE. A PRECONDITION_FAILED will be returned if an invalid
        # transition is requested. The state can only be set to COMPLETE once. A
        # FAILED_PRECONDITION will be returned if the state is set to COMPLETE multiple
        # times. If the state is set to COMPLETE, all the in-progress steps within the
        # execution will be set as COMPLETE. If the outcome of the step is not set, the
        # outcome will be set to INCONCLUSIVE. - In response always set - In create/
        # update request: optional
        # Corresponds to the JSON property `state`
        # @return [String]
        attr_accessor :state
      
        # TestExecution Matrix ID that the TestExecutionService uses. - In response:
        # present if set by create - In create: optional - In update: never set
        # Corresponds to the JSON property `testExecutionMatrixId`
        # @return [String]
        attr_accessor :test_execution_matrix_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @completion_time = args[:completion_time] if args.key?(:completion_time)
          @creation_time = args[:creation_time] if args.key?(:creation_time)
          @dimension_definitions = args[:dimension_definitions] if args.key?(:dimension_definitions)
          @execution_id = args[:execution_id] if args.key?(:execution_id)
          @outcome = args[:outcome] if args.key?(:outcome)
          @specification = args[:specification] if args.key?(:specification)
          @state = args[:state] if args.key?(:state)
          @test_execution_matrix_id = args[:test_execution_matrix_id] if args.key?(:test_execution_matrix_id)
        end
      end
      
      # Failed to install the APK.
      class FailedToInstall
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Details for an outcome with a FAILURE outcome summary.
      class FailureDetail
        include Google::Apis::Core::Hashable
      
        # If the failure was severe because the system (app) under test crashed.
        # Corresponds to the JSON property `crashed`
        # @return [Boolean]
        attr_accessor :crashed
        alias_method :crashed?, :crashed
      
        # If the device ran out of memory during a test, causing the test to crash.
        # Corresponds to the JSON property `deviceOutOfMemory`
        # @return [Boolean]
        attr_accessor :device_out_of_memory
        alias_method :device_out_of_memory?, :device_out_of_memory
      
        # 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.
        # Corresponds to the JSON property `failedRoboscript`
        # @return [Boolean]
        attr_accessor :failed_roboscript
        alias_method :failed_roboscript?, :failed_roboscript
      
        # 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.
        # Corresponds to the JSON property `notInstalled`
        # @return [Boolean]
        attr_accessor :not_installed
        alias_method :not_installed?, :not_installed
      
        # If a native process (including any other than the app) crashed.
        # Corresponds to the JSON property `otherNativeCrash`
        # @return [Boolean]
        attr_accessor :other_native_crash
        alias_method :other_native_crash?, :other_native_crash
      
        # If the test overran some time limit, and that is why it failed.
        # Corresponds to the JSON property `timedOut`
        # @return [Boolean]
        attr_accessor :timed_out
        alias_method :timed_out?, :timed_out
      
        # If the robo was unable to crawl the app; perhaps because the app did not start.
        # Corresponds to the JSON property `unableToCrawl`
        # @return [Boolean]
        attr_accessor :unable_to_crawl
        alias_method :unable_to_crawl?, :unable_to_crawl
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @crashed = args[:crashed] if args.key?(:crashed)
          @device_out_of_memory = args[:device_out_of_memory] if args.key?(:device_out_of_memory)
          @failed_roboscript = args[:failed_roboscript] if args.key?(:failed_roboscript)
          @not_installed = args[:not_installed] if args.key?(:not_installed)
          @other_native_crash = args[:other_native_crash] if args.key?(:other_native_crash)
          @timed_out = args[:timed_out] if args.key?(:timed_out)
          @unable_to_crawl = args[:unable_to_crawl] if args.key?(:unable_to_crawl)
        end
      end
      
      # Additional details for a fatal exception.
      class FatalException
        include Google::Apis::Core::Hashable
      
        # A stacktrace.
        # Corresponds to the JSON property `stackTrace`
        # @return [Google::Apis::ToolresultsV1beta3::StackTrace]
        attr_accessor :stack_trace
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @stack_trace = args[:stack_trace] if args.key?(:stack_trace)
        end
      end
      
      # A reference to a file.
      class FileReference
        include Google::Apis::Core::Hashable
      
        # 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
        # Corresponds to the JSON property `fileUri`
        # @return [String]
        attr_accessor :file_uri
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @file_uri = args[:file_uri] if args.key?(:file_uri)
        end
      end
      
      # 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+.
      class GraphicsStats
        include Google::Apis::Core::Hashable
      
        # Histogram of frame render times. There should be 154 buckets ranging from [5ms,
        # 6ms) to [4950ms, infinity)
        # Corresponds to the JSON property `buckets`
        # @return [Array<Google::Apis::ToolresultsV1beta3::GraphicsStatsBucket>]
        attr_accessor :buckets
      
        # Total "high input latency" events.
        # Corresponds to the JSON property `highInputLatencyCount`
        # @return [Fixnum]
        attr_accessor :high_input_latency_count
      
        # Total frames with slow render time. Should be <= total_frames.
        # Corresponds to the JSON property `jankyFrames`
        # @return [Fixnum]
        attr_accessor :janky_frames
      
        # Total "missed vsync" events.
        # Corresponds to the JSON property `missedVsyncCount`
        # @return [Fixnum]
        attr_accessor :missed_vsync_count
      
        # 50th percentile frame render time in milliseconds.
        # Corresponds to the JSON property `p50Millis`
        # @return [Fixnum]
        attr_accessor :p50_millis
      
        # 90th percentile frame render time in milliseconds.
        # Corresponds to the JSON property `p90Millis`
        # @return [Fixnum]
        attr_accessor :p90_millis
      
        # 95th percentile frame render time in milliseconds.
        # Corresponds to the JSON property `p95Millis`
        # @return [Fixnum]
        attr_accessor :p95_millis
      
        # 99th percentile frame render time in milliseconds.
        # Corresponds to the JSON property `p99Millis`
        # @return [Fixnum]
        attr_accessor :p99_millis
      
        # Total "slow bitmap upload" events.
        # Corresponds to the JSON property `slowBitmapUploadCount`
        # @return [Fixnum]
        attr_accessor :slow_bitmap_upload_count
      
        # Total "slow draw" events.
        # Corresponds to the JSON property `slowDrawCount`
        # @return [Fixnum]
        attr_accessor :slow_draw_count
      
        # Total "slow UI thread" events.
        # Corresponds to the JSON property `slowUiThreadCount`
        # @return [Fixnum]
        attr_accessor :slow_ui_thread_count
      
        # Total frames rendered by package.
        # Corresponds to the JSON property `totalFrames`
        # @return [Fixnum]
        attr_accessor :total_frames
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @buckets = args[:buckets] if args.key?(:buckets)
          @high_input_latency_count = args[:high_input_latency_count] if args.key?(:high_input_latency_count)
          @janky_frames = args[:janky_frames] if args.key?(:janky_frames)
          @missed_vsync_count = args[:missed_vsync_count] if args.key?(:missed_vsync_count)
          @p50_millis = args[:p50_millis] if args.key?(:p50_millis)
          @p90_millis = args[:p90_millis] if args.key?(:p90_millis)
          @p95_millis = args[:p95_millis] if args.key?(:p95_millis)
          @p99_millis = args[:p99_millis] if args.key?(:p99_millis)
          @slow_bitmap_upload_count = args[:slow_bitmap_upload_count] if args.key?(:slow_bitmap_upload_count)
          @slow_draw_count = args[:slow_draw_count] if args.key?(:slow_draw_count)
          @slow_ui_thread_count = args[:slow_ui_thread_count] if args.key?(:slow_ui_thread_count)
          @total_frames = args[:total_frames] if args.key?(:total_frames)
        end
      end
      
      # 
      class GraphicsStatsBucket
        include Google::Apis::Core::Hashable
      
        # Number of frames in the bucket.
        # Corresponds to the JSON property `frameCount`
        # @return [Fixnum]
        attr_accessor :frame_count
      
        # Lower bound of render time in milliseconds.
        # Corresponds to the JSON property `renderMillis`
        # @return [Fixnum]
        attr_accessor :render_millis
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @frame_count = args[:frame_count] if args.key?(:frame_count)
          @render_millis = args[:render_millis] if args.key?(:render_millis)
        end
      end
      
      # A History represents a sorted list of Executions ordered by the
      # start_timestamp_millis field (descending). It can be used to group all the
      # Executions of a continuous build. Note that the ordering only operates on one-
      # dimension. If a repository has multiple branches, it means that multiple
      # histories will need to be used in order to order Executions per branch.
      class History
        include Google::Apis::Core::Hashable
      
        # A short human-readable (plain text) name to display in the UI. Maximum of 100
        # characters. - In response: present if set during create. - In create request:
        # optional
        # Corresponds to the JSON property `displayName`
        # @return [String]
        attr_accessor :display_name
      
        # A unique identifier within a project for this History. Returns
        # INVALID_ARGUMENT if this field is set or overwritten by the caller. - In
        # response always set - In create request: never set
        # Corresponds to the JSON property `historyId`
        # @return [String]
        attr_accessor :history_id
      
        # A name to uniquely identify a history within a project. Maximum of 200
        # characters. - In response always set - In create request: always set
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        # The platform of the test history. - In response: always set. Returns the
        # platform of the last execution if unknown.
        # Corresponds to the JSON property `testPlatform`
        # @return [String]
        attr_accessor :test_platform
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @display_name = args[:display_name] if args.key?(:display_name)
          @history_id = args[:history_id] if args.key?(:history_id)
          @name = args[:name] if args.key?(:name)
          @test_platform = args[:test_platform] if args.key?(:test_platform)
        end
      end
      
      # An image, with a link to the main image and a thumbnail.
      class Image
        include Google::Apis::Core::Hashable
      
        # The `Status` type defines a logical error model that is suitable for different
        # programming environments, including REST APIs and RPC APIs. It is used by [
        # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
        # data: error code, error message, and error details. You can find out more
        # about this error model and how to work with it in the [API Design Guide](https:
        # //cloud.google.com/apis/design/errors).
        # Corresponds to the JSON property `error`
        # @return [Google::Apis::ToolresultsV1beta3::Status]
        attr_accessor :error
      
        # A reference to a ToolExecution output file.
        # Corresponds to the JSON property `sourceImage`
        # @return [Google::Apis::ToolresultsV1beta3::ToolOutputReference]
        attr_accessor :source_image
      
        # The step to which the image is attached. Always set.
        # Corresponds to the JSON property `stepId`
        # @return [String]
        attr_accessor :step_id
      
        # A single thumbnail, with its size and format.
        # Corresponds to the JSON property `thumbnail`
        # @return [Google::Apis::ToolresultsV1beta3::Thumbnail]
        attr_accessor :thumbnail
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @error = args[:error] if args.key?(:error)
          @source_image = args[:source_image] if args.key?(:source_image)
          @step_id = args[:step_id] if args.key?(:step_id)
          @thumbnail = args[:thumbnail] if args.key?(:thumbnail)
        end
      end
      
      # Additional details of in-app purchases encountered during the crawl.
      class InAppPurchasesFound
        include Google::Apis::Core::Hashable
      
        # The total number of in-app purchases flows explored: how many times the robo
        # tries to buy a SKU.
        # Corresponds to the JSON property `inAppPurchasesFlowsExplored`
        # @return [Fixnum]
        attr_accessor :in_app_purchases_flows_explored
      
        # The total number of in-app purchases flows started.
        # Corresponds to the JSON property `inAppPurchasesFlowsStarted`
        # @return [Fixnum]
        attr_accessor :in_app_purchases_flows_started
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @in_app_purchases_flows_explored = args[:in_app_purchases_flows_explored] if args.key?(:in_app_purchases_flows_explored)
          @in_app_purchases_flows_started = args[:in_app_purchases_flows_started] if args.key?(:in_app_purchases_flows_started)
        end
      end
      
      # Details for an outcome with an INCONCLUSIVE outcome summary.
      class InconclusiveDetail
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `abortedByUser`
        # @return [Boolean]
        attr_accessor :aborted_by_user
        alias_method :aborted_by_user?, :aborted_by_user
      
        # If results are being provided to the user in certain cases of infrastructure
        # failures
        # Corresponds to the JSON property `hasErrorLogs`
        # @return [Boolean]
        attr_accessor :has_error_logs
        alias_method :has_error_logs?, :has_error_logs
      
        # 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.
        # Corresponds to the JSON property `infrastructureFailure`
        # @return [Boolean]
        attr_accessor :infrastructure_failure
        alias_method :infrastructure_failure?, :infrastructure_failure
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @aborted_by_user = args[:aborted_by_user] if args.key?(:aborted_by_user)
          @has_error_logs = args[:has_error_logs] if args.key?(:has_error_logs)
          @infrastructure_failure = args[:infrastructure_failure] if args.key?(:infrastructure_failure)
        end
      end
      
      # Step Id and outcome of each individual step that was run as a group with other
      # steps with the same configuration.
      class IndividualOutcome
        include Google::Apis::Core::Hashable
      
        # Unique int given to each step. Ranges from 0(inclusive) to total number of
        # steps(exclusive). The primary step is 0.
        # Corresponds to the JSON property `multistepNumber`
        # @return [Fixnum]
        attr_accessor :multistep_number
      
        # 
        # Corresponds to the JSON property `outcomeSummary`
        # @return [String]
        attr_accessor :outcome_summary
      
        # 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.
        # Corresponds to the JSON property `runDuration`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :run_duration
      
        # 
        # Corresponds to the JSON property `stepId`
        # @return [String]
        attr_accessor :step_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @multistep_number = args[:multistep_number] if args.key?(:multistep_number)
          @outcome_summary = args[:outcome_summary] if args.key?(:outcome_summary)
          @run_duration = args[:run_duration] if args.key?(:run_duration)
          @step_id = args[:step_id] if args.key?(:step_id)
        end
      end
      
      # A warning that Robo did not crawl potentially important parts of the app.
      class InsufficientCoverage
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Additional details for an iOS app crash.
      class IosAppCrashed
        include Google::Apis::Core::Hashable
      
        # A stacktrace.
        # Corresponds to the JSON property `stackTrace`
        # @return [Google::Apis::ToolresultsV1beta3::StackTrace]
        attr_accessor :stack_trace
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @stack_trace = args[:stack_trace] if args.key?(:stack_trace)
        end
      end
      
      # iOS app information
      class IosAppInfo
        include Google::Apis::Core::Hashable
      
        # The name of the app. Required
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @name = args[:name] if args.key?(:name)
        end
      end
      
      # A Robo test for an iOS application.
      class IosRoboTest
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # A iOS mobile test specification
      class IosTest
        include Google::Apis::Core::Hashable
      
        # iOS app information
        # Corresponds to the JSON property `iosAppInfo`
        # @return [Google::Apis::ToolresultsV1beta3::IosAppInfo]
        attr_accessor :ios_app_info
      
        # A Robo test for an iOS application.
        # Corresponds to the JSON property `iosRoboTest`
        # @return [Google::Apis::ToolresultsV1beta3::IosRoboTest]
        attr_accessor :ios_robo_test
      
        # A game loop test of an iOS application.
        # Corresponds to the JSON property `iosTestLoop`
        # @return [Google::Apis::ToolresultsV1beta3::IosTestLoop]
        attr_accessor :ios_test_loop
      
        # A test of an iOS application that uses the XCTest framework.
        # Corresponds to the JSON property `iosXcTest`
        # @return [Google::Apis::ToolresultsV1beta3::IosXcTest]
        attr_accessor :ios_xc_test
      
        # 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.
        # Corresponds to the JSON property `testTimeout`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :test_timeout
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @ios_app_info = args[:ios_app_info] if args.key?(:ios_app_info)
          @ios_robo_test = args[:ios_robo_test] if args.key?(:ios_robo_test)
          @ios_test_loop = args[:ios_test_loop] if args.key?(:ios_test_loop)
          @ios_xc_test = args[:ios_xc_test] if args.key?(:ios_xc_test)
          @test_timeout = args[:test_timeout] if args.key?(:test_timeout)
        end
      end
      
      # A game loop test of an iOS application.
      class IosTestLoop
        include Google::Apis::Core::Hashable
      
        # Bundle ID of the app.
        # Corresponds to the JSON property `bundleId`
        # @return [String]
        attr_accessor :bundle_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @bundle_id = args[:bundle_id] if args.key?(:bundle_id)
        end
      end
      
      # A test of an iOS application that uses the XCTest framework.
      class IosXcTest
        include Google::Apis::Core::Hashable
      
        # Bundle ID of the app.
        # Corresponds to the JSON property `bundleId`
        # @return [String]
        attr_accessor :bundle_id
      
        # Xcode version that the test was run with.
        # Corresponds to the JSON property `xcodeVersion`
        # @return [String]
        attr_accessor :xcode_version
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @bundle_id = args[:bundle_id] if args.key?(:bundle_id)
          @xcode_version = args[:xcode_version] if args.key?(:xcode_version)
        end
      end
      
      # Failed to find the launcher activity of an app.
      class LauncherActivityNotFound
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Response message for EnvironmentService.ListEnvironments.
      class ListEnvironmentsResponse
        include Google::Apis::Core::Hashable
      
        # Environments. Always set.
        # Corresponds to the JSON property `environments`
        # @return [Array<Google::Apis::ToolresultsV1beta3::Environment>]
        attr_accessor :environments
      
        # A Execution id Always set.
        # Corresponds to the JSON property `executionId`
        # @return [String]
        attr_accessor :execution_id
      
        # A History id. Always set.
        # Corresponds to the JSON property `historyId`
        # @return [String]
        attr_accessor :history_id
      
        # A continuation token to resume the query at the next item. Will only be set if
        # there are more Environments to fetch.
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        # A Project id. Always set.
        # Corresponds to the JSON property `projectId`
        # @return [String]
        attr_accessor :project_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @environments = args[:environments] if args.key?(:environments)
          @execution_id = args[:execution_id] if args.key?(:execution_id)
          @history_id = args[:history_id] if args.key?(:history_id)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
          @project_id = args[:project_id] if args.key?(:project_id)
        end
      end
      
      # 
      class ListExecutionsResponse
        include Google::Apis::Core::Hashable
      
        # Executions. Always set.
        # Corresponds to the JSON property `executions`
        # @return [Array<Google::Apis::ToolresultsV1beta3::Execution>]
        attr_accessor :executions
      
        # A continuation token to resume the query at the next item. Will only be set if
        # there are more Executions to fetch.
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @executions = args[:executions] if args.key?(:executions)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
        end
      end
      
      # Response message for HistoryService.List
      class ListHistoriesResponse
        include Google::Apis::Core::Hashable
      
        # Histories.
        # Corresponds to the JSON property `histories`
        # @return [Array<Google::Apis::ToolresultsV1beta3::History>]
        attr_accessor :histories
      
        # A continuation token to resume the query at the next item. Will only be set if
        # there are more histories to fetch. Tokens are valid for up to one hour from
        # the time of the first list request. For instance, if you make a list request
        # at 1PM and use the token from this first request 10 minutes later, the token
        # from this second response will only be valid for 50 minutes.
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @histories = args[:histories] if args.key?(:histories)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
        end
      end
      
      # 
      class ListPerfSampleSeriesResponse
        include Google::Apis::Core::Hashable
      
        # The resulting PerfSampleSeries sorted by id
        # Corresponds to the JSON property `perfSampleSeries`
        # @return [Array<Google::Apis::ToolresultsV1beta3::PerfSampleSeries>]
        attr_accessor :perf_sample_series
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @perf_sample_series = args[:perf_sample_series] if args.key?(:perf_sample_series)
        end
      end
      
      # 
      class ListPerfSamplesResponse
        include Google::Apis::Core::Hashable
      
        # Optional, returned if result size exceeds the page size specified in the
        # request (or the default page size, 500, if unspecified). It indicates the last
        # sample timestamp to be used as page_token in subsequent request
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        # 
        # Corresponds to the JSON property `perfSamples`
        # @return [Array<Google::Apis::ToolresultsV1beta3::PerfSample>]
        attr_accessor :perf_samples
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
          @perf_samples = args[:perf_samples] if args.key?(:perf_samples)
        end
      end
      
      # 
      class ListScreenshotClustersResponse
        include Google::Apis::Core::Hashable
      
        # The set of clusters associated with an execution Always set
        # Corresponds to the JSON property `clusters`
        # @return [Array<Google::Apis::ToolresultsV1beta3::ScreenshotCluster>]
        attr_accessor :clusters
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @clusters = args[:clusters] if args.key?(:clusters)
        end
      end
      
      # Response message for AccessibilityService.ListStepAccessibilityClusters.
      class ListStepAccessibilityClustersResponse
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `clusters`
        # @return [Array<Google::Apis::ToolresultsV1beta3::SuggestionClusterProto>]
        attr_accessor :clusters
      
        # A full resource name of the step. For example, projects/my-project/histories/
        # bh.1234567890abcdef/executions/ 1234567890123456789/steps/bs.1234567890abcdef
        # Always presents.
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @clusters = args[:clusters] if args.key?(:clusters)
          @name = args[:name] if args.key?(:name)
        end
      end
      
      # A response containing the thumbnails in a step.
      class ListStepThumbnailsResponse
        include Google::Apis::Core::Hashable
      
        # A continuation token to resume the query at the next item. If set, indicates
        # that there are more thumbnails to read, by calling list again with this value
        # in the page_token field.
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        # A list of image data. Images are returned in a deterministic order; they are
        # ordered by these factors, in order of importance: * First, by their associated
        # test case. Images without a test case are considered greater than images with
        # one. * Second, by their creation time. Images without a creation time are
        # greater than images with one. * Third, by the order in which they were added
        # to the step (by calls to CreateStep or UpdateStep).
        # Corresponds to the JSON property `thumbnails`
        # @return [Array<Google::Apis::ToolresultsV1beta3::Image>]
        attr_accessor :thumbnails
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
          @thumbnails = args[:thumbnails] if args.key?(:thumbnails)
        end
      end
      
      # Response message for StepService.List.
      class ListStepsResponse
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        # Steps.
        # Corresponds to the JSON property `steps`
        # @return [Array<Google::Apis::ToolresultsV1beta3::Step>]
        attr_accessor :steps
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
          @steps = args[:steps] if args.key?(:steps)
        end
      end
      
      # Response message for StepService.ListTestCases.
      class ListTestCasesResponse
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `nextPageToken`
        # @return [String]
        attr_accessor :next_page_token
      
        # List of test cases.
        # Corresponds to the JSON property `testCases`
        # @return [Array<Google::Apis::ToolresultsV1beta3::TestCase>]
        attr_accessor :test_cases
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @next_page_token = args[:next_page_token] if args.key?(:next_page_token)
          @test_cases = args[:test_cases] if args.key?(:test_cases)
        end
      end
      
      # One dimension of the matrix of different runs of a step.
      class MatrixDimensionDefinition
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # 
      class MemoryInfo
        include Google::Apis::Core::Hashable
      
        # Maximum memory that can be allocated to the process in KiB
        # Corresponds to the JSON property `memoryCapInKibibyte`
        # @return [Fixnum]
        attr_accessor :memory_cap_in_kibibyte
      
        # Total memory available on the device in KiB
        # Corresponds to the JSON property `memoryTotalInKibibyte`
        # @return [Fixnum]
        attr_accessor :memory_total_in_kibibyte
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @memory_cap_in_kibibyte = args[:memory_cap_in_kibibyte] if args.key?(:memory_cap_in_kibibyte)
          @memory_total_in_kibibyte = args[:memory_total_in_kibibyte] if args.key?(:memory_total_in_kibibyte)
        end
      end
      
      # Merged test result for environment. If the environment has only one step (no
      # reruns or shards), then the merged result is the same as the step result. If
      # the environment has multiple shards and/or reruns, then the results of shards
      # and reruns that belong to the same environment are merged into one environment
      # result.
      class MergedResult
        include Google::Apis::Core::Hashable
      
        # Interprets a result so that humans and machines can act on it.
        # Corresponds to the JSON property `outcome`
        # @return [Google::Apis::ToolresultsV1beta3::Outcome]
        attr_accessor :outcome
      
        # State of the resource
        # Corresponds to the JSON property `state`
        # @return [String]
        attr_accessor :state
      
        # The combined and rolled-up result of each test suite that was run as part of
        # this environment. Combining: When the test cases from a suite are run in
        # different steps (sharding), the results are added back together in one
        # overview. (e.g., if shard1 has 2 failures and shard2 has 1 failure than the
        # overview failure_count = 3). Rollup: When test cases from the same suite are
        # run multiple times (flaky), the results are combined (e.g., if testcase1.run1
        # fails, testcase1.run2 passes, and both testcase2.run1 and testcase2.run2 fail
        # then the overview flaky_count = 1 and failure_count = 1).
        # Corresponds to the JSON property `testSuiteOverviews`
        # @return [Array<Google::Apis::ToolresultsV1beta3::TestSuiteOverview>]
        attr_accessor :test_suite_overviews
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @outcome = args[:outcome] if args.key?(:outcome)
          @state = args[:state] if args.key?(:state)
          @test_suite_overviews = args[:test_suite_overviews] if args.key?(:test_suite_overviews)
        end
      end
      
      # Details when multiple steps are run with the same configuration as a group.
      class MultiStep
        include Google::Apis::Core::Hashable
      
        # Unique int given to each step. Ranges from 0(inclusive) to total number of
        # steps(exclusive). The primary step is 0.
        # Corresponds to the JSON property `multistepNumber`
        # @return [Fixnum]
        attr_accessor :multistep_number
      
        # Stores rollup test status of multiple steps that were run as a group and
        # outcome of each individual step.
        # Corresponds to the JSON property `primaryStep`
        # @return [Google::Apis::ToolresultsV1beta3::PrimaryStep]
        attr_accessor :primary_step
      
        # Step Id of the primary (original) step, which might be this step.
        # Corresponds to the JSON property `primaryStepId`
        # @return [String]
        attr_accessor :primary_step_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @multistep_number = args[:multistep_number] if args.key?(:multistep_number)
          @primary_step = args[:primary_step] if args.key?(:primary_step)
          @primary_step_id = args[:primary_step_id] if args.key?(:primary_step_id)
        end
      end
      
      # Additional details for a native crash.
      class NativeCrash
        include Google::Apis::Core::Hashable
      
        # A stacktrace.
        # Corresponds to the JSON property `stackTrace`
        # @return [Google::Apis::ToolresultsV1beta3::StackTrace]
        attr_accessor :stack_trace
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @stack_trace = args[:stack_trace] if args.key?(:stack_trace)
        end
      end
      
      # A non-sdk API and examples of it being called along with other metadata See
      # https://developer.android.com/distribute/best-practices/develop/restrictions-
      # non-sdk-interfaces
      class NonSdkApi
        include Google::Apis::Core::Hashable
      
        # The signature of the Non-SDK API
        # Corresponds to the JSON property `apiSignature`
        # @return [String]
        attr_accessor :api_signature
      
        # Example stack traces of this API being called.
        # Corresponds to the JSON property `exampleStackTraces`
        # @return [Array<String>]
        attr_accessor :example_stack_traces
      
        # Optional debugging insights for non-SDK API violations.
        # Corresponds to the JSON property `insights`
        # @return [Array<Google::Apis::ToolresultsV1beta3::NonSdkApiInsight>]
        attr_accessor :insights
      
        # The total number of times this API was observed to have been called.
        # Corresponds to the JSON property `invocationCount`
        # @return [Fixnum]
        attr_accessor :invocation_count
      
        # Which list this API appears on
        # Corresponds to the JSON property `list`
        # @return [String]
        attr_accessor :list
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @api_signature = args[:api_signature] if args.key?(:api_signature)
          @example_stack_traces = args[:example_stack_traces] if args.key?(:example_stack_traces)
          @insights = args[:insights] if args.key?(:insights)
          @invocation_count = args[:invocation_count] if args.key?(:invocation_count)
          @list = args[:list] if args.key?(:list)
        end
      end
      
      # Non-SDK API insights (to address debugging solutions).
      class NonSdkApiInsight
        include Google::Apis::Core::Hashable
      
        # Optional sample stack traces, for which this insight applies (there should be
        # at least one).
        # Corresponds to the JSON property `exampleTraceMessages`
        # @return [Array<String>]
        attr_accessor :example_trace_messages
      
        # A unique ID, to be used for determining the effectiveness of this particular
        # insight in the context of a matcher. (required)
        # Corresponds to the JSON property `matcherId`
        # @return [String]
        attr_accessor :matcher_id
      
        # This insight indicates that the hidden API usage originates from a Google-
        # provided library. Users need not take any action.
        # Corresponds to the JSON property `pendingGoogleUpdateInsight`
        # @return [Google::Apis::ToolresultsV1beta3::PendingGoogleUpdateInsight]
        attr_accessor :pending_google_update_insight
      
        # This insight is a recommendation to upgrade a given library to the specified
        # version, in order to avoid dependencies on non-SDK APIs.
        # Corresponds to the JSON property `upgradeInsight`
        # @return [Google::Apis::ToolresultsV1beta3::UpgradeInsight]
        attr_accessor :upgrade_insight
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @example_trace_messages = args[:example_trace_messages] if args.key?(:example_trace_messages)
          @matcher_id = args[:matcher_id] if args.key?(:matcher_id)
          @pending_google_update_insight = args[:pending_google_update_insight] if args.key?(:pending_google_update_insight)
          @upgrade_insight = args[:upgrade_insight] if args.key?(:upgrade_insight)
        end
      end
      
      # Additional details for a non-sdk API usage violation.
      class NonSdkApiUsageViolation
        include Google::Apis::Core::Hashable
      
        # Signatures of a subset of those hidden API's.
        # Corresponds to the JSON property `apiSignatures`
        # @return [Array<String>]
        attr_accessor :api_signatures
      
        # Total number of unique hidden API's accessed.
        # Corresponds to the JSON property `uniqueApis`
        # @return [Fixnum]
        attr_accessor :unique_apis
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @api_signatures = args[:api_signatures] if args.key?(:api_signatures)
          @unique_apis = args[:unique_apis] if args.key?(:unique_apis)
        end
      end
      
      # Contains a summary and examples of non-sdk API usage violations.
      class NonSdkApiUsageViolationReport
        include Google::Apis::Core::Hashable
      
        # Examples of the detected API usages.
        # Corresponds to the JSON property `exampleApis`
        # @return [Array<Google::Apis::ToolresultsV1beta3::NonSdkApi>]
        attr_accessor :example_apis
      
        # Minimum API level required for the application to run.
        # Corresponds to the JSON property `minSdkVersion`
        # @return [Fixnum]
        attr_accessor :min_sdk_version
      
        # Specifies the API Level on which the application is designed to run.
        # Corresponds to the JSON property `targetSdkVersion`
        # @return [Fixnum]
        attr_accessor :target_sdk_version
      
        # Total number of unique Non-SDK API's accessed.
        # Corresponds to the JSON property `uniqueApis`
        # @return [Fixnum]
        attr_accessor :unique_apis
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @example_apis = args[:example_apis] if args.key?(:example_apis)
          @min_sdk_version = args[:min_sdk_version] if args.key?(:min_sdk_version)
          @target_sdk_version = args[:target_sdk_version] if args.key?(:target_sdk_version)
          @unique_apis = args[:unique_apis] if args.key?(:unique_apis)
        end
      end
      
      # Interprets a result so that humans and machines can act on it.
      class Outcome
        include Google::Apis::Core::Hashable
      
        # Details for an outcome with a FAILURE outcome summary.
        # Corresponds to the JSON property `failureDetail`
        # @return [Google::Apis::ToolresultsV1beta3::FailureDetail]
        attr_accessor :failure_detail
      
        # Details for an outcome with an INCONCLUSIVE outcome summary.
        # Corresponds to the JSON property `inconclusiveDetail`
        # @return [Google::Apis::ToolresultsV1beta3::InconclusiveDetail]
        attr_accessor :inconclusive_detail
      
        # Details for an outcome with a SKIPPED outcome summary.
        # Corresponds to the JSON property `skippedDetail`
        # @return [Google::Apis::ToolresultsV1beta3::SkippedDetail]
        attr_accessor :skipped_detail
      
        # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange
        # Corresponds to the JSON property `successDetail`
        # @return [Google::Apis::ToolresultsV1beta3::SuccessDetail]
        attr_accessor :success_detail
      
        # The simplest way to interpret a result. Required
        # Corresponds to the JSON property `summary`
        # @return [String]
        attr_accessor :summary
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @failure_detail = args[:failure_detail] if args.key?(:failure_detail)
          @inconclusive_detail = args[:inconclusive_detail] if args.key?(:inconclusive_detail)
          @skipped_detail = args[:skipped_detail] if args.key?(:skipped_detail)
          @success_detail = args[:success_detail] if args.key?(:success_detail)
          @summary = args[:summary] if args.key?(:summary)
        end
      end
      
      # A warning that Robo encountered a screen that has overlapping clickable
      # elements; this may indicate a potential UI issue.
      class OverlappingUiElements
        include Google::Apis::Core::Hashable
      
        # Resource names of the overlapping screen elements
        # Corresponds to the JSON property `resourceName`
        # @return [Array<String>]
        attr_accessor :resource_name
      
        # The screen id of the elements
        # Corresponds to the JSON property `screenId`
        # @return [String]
        attr_accessor :screen_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @resource_name = args[:resource_name] if args.key?(:resource_name)
          @screen_id = args[:screen_id] if args.key?(:screen_id)
        end
      end
      
      # This insight indicates that the hidden API usage originates from a Google-
      # provided library. Users need not take any action.
      class PendingGoogleUpdateInsight
        include Google::Apis::Core::Hashable
      
        # The name of the Google-provided library with the non-SDK API dependency.
        # Corresponds to the JSON property `nameOfGoogleLibrary`
        # @return [String]
        attr_accessor :name_of_google_library
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @name_of_google_library = args[:name_of_google_library] if args.key?(:name_of_google_library)
        end
      end
      
      # Encapsulates performance environment info
      class PerfEnvironment
        include Google::Apis::Core::Hashable
      
        # CPU related environment info
        # Corresponds to the JSON property `cpuInfo`
        # @return [Google::Apis::ToolresultsV1beta3::CpuInfo]
        attr_accessor :cpu_info
      
        # Memory related environment info
        # Corresponds to the JSON property `memoryInfo`
        # @return [Google::Apis::ToolresultsV1beta3::MemoryInfo]
        attr_accessor :memory_info
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @cpu_info = args[:cpu_info] if args.key?(:cpu_info)
          @memory_info = args[:memory_info] if args.key?(:memory_info)
        end
      end
      
      # A summary of perf metrics collected and performance environment info
      class PerfMetricsSummary
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `appStartTime`
        # @return [Google::Apis::ToolresultsV1beta3::AppStartTime]
        attr_accessor :app_start_time
      
        # A tool results execution ID. @OutputOnly
        # Corresponds to the JSON property `executionId`
        # @return [String]
        attr_accessor :execution_id
      
        # 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+.
        # Corresponds to the JSON property `graphicsStats`
        # @return [Google::Apis::ToolresultsV1beta3::GraphicsStats]
        attr_accessor :graphics_stats
      
        # A tool results history ID. @OutputOnly
        # Corresponds to the JSON property `historyId`
        # @return [String]
        attr_accessor :history_id
      
        # Encapsulates performance environment info
        # Corresponds to the JSON property `perfEnvironment`
        # @return [Google::Apis::ToolresultsV1beta3::PerfEnvironment]
        attr_accessor :perf_environment
      
        # Set of resource collected
        # Corresponds to the JSON property `perfMetrics`
        # @return [Array<String>]
        attr_accessor :perf_metrics
      
        # The cloud project @OutputOnly
        # Corresponds to the JSON property `projectId`
        # @return [String]
        attr_accessor :project_id
      
        # A tool results step ID. @OutputOnly
        # Corresponds to the JSON property `stepId`
        # @return [String]
        attr_accessor :step_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @app_start_time = args[:app_start_time] if args.key?(:app_start_time)
          @execution_id = args[:execution_id] if args.key?(:execution_id)
          @graphics_stats = args[:graphics_stats] if args.key?(:graphics_stats)
          @history_id = args[:history_id] if args.key?(:history_id)
          @perf_environment = args[:perf_environment] if args.key?(:perf_environment)
          @perf_metrics = args[:perf_metrics] if args.key?(:perf_metrics)
          @project_id = args[:project_id] if args.key?(:project_id)
          @step_id = args[:step_id] if args.key?(:step_id)
        end
      end
      
      # Resource representing a single performance measure or data point
      class PerfSample
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `sampleTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :sample_time
      
        # Value observed
        # Corresponds to the JSON property `value`
        # @return [Float]
        attr_accessor :value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @sample_time = args[:sample_time] if args.key?(:sample_time)
          @value = args[:value] if args.key?(:value)
        end
      end
      
      # Resource representing a collection of performance samples (or data points)
      class PerfSampleSeries
        include Google::Apis::Core::Hashable
      
        # Encapsulates the metadata for basic sample series represented by a line chart
        # Corresponds to the JSON property `basicPerfSampleSeries`
        # @return [Google::Apis::ToolresultsV1beta3::BasicPerfSampleSeries]
        attr_accessor :basic_perf_sample_series
      
        # A tool results execution ID. @OutputOnly
        # Corresponds to the JSON property `executionId`
        # @return [String]
        attr_accessor :execution_id
      
        # A tool results history ID. @OutputOnly
        # Corresponds to the JSON property `historyId`
        # @return [String]
        attr_accessor :history_id
      
        # The cloud project @OutputOnly
        # Corresponds to the JSON property `projectId`
        # @return [String]
        attr_accessor :project_id
      
        # A sample series id @OutputOnly
        # Corresponds to the JSON property `sampleSeriesId`
        # @return [String]
        attr_accessor :sample_series_id
      
        # A tool results step ID. @OutputOnly
        # Corresponds to the JSON property `stepId`
        # @return [String]
        attr_accessor :step_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @basic_perf_sample_series = args[:basic_perf_sample_series] if args.key?(:basic_perf_sample_series)
          @execution_id = args[:execution_id] if args.key?(:execution_id)
          @history_id = args[:history_id] if args.key?(:history_id)
          @project_id = args[:project_id] if args.key?(:project_id)
          @sample_series_id = args[:sample_series_id] if args.key?(:sample_series_id)
          @step_id = args[:step_id] if args.key?(:step_id)
        end
      end
      
      # A notification that Robo signed in with Google.
      class PerformedGoogleLogin
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # A notification that Robo performed some monkey actions.
      class PerformedMonkeyActions
        include Google::Apis::Core::Hashable
      
        # The total number of monkey actions performed during the crawl.
        # Corresponds to the JSON property `totalActions`
        # @return [Fixnum]
        attr_accessor :total_actions
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @total_actions = args[:total_actions] if args.key?(:total_actions)
        end
      end
      
      # Stores rollup test status of multiple steps that were run as a group and
      # outcome of each individual step.
      class PrimaryStep
        include Google::Apis::Core::Hashable
      
        # Step Id and outcome of each individual step.
        # Corresponds to the JSON property `individualOutcome`
        # @return [Array<Google::Apis::ToolresultsV1beta3::IndividualOutcome>]
        attr_accessor :individual_outcome
      
        # Rollup test status of multiple steps that were run with the same configuration
        # as a group.
        # Corresponds to the JSON property `rollUp`
        # @return [String]
        attr_accessor :roll_up
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @individual_outcome = args[:individual_outcome] if args.key?(:individual_outcome)
          @roll_up = args[:roll_up] if args.key?(:roll_up)
        end
      end
      
      # Per-project settings for the Tool Results service.
      class ProjectSettings
        include Google::Apis::Core::Hashable
      
        # The name of the Google Cloud Storage bucket to which results are written. By
        # default, this is unset. In update request: optional In response: optional
        # Corresponds to the JSON property `defaultBucket`
        # @return [String]
        attr_accessor :default_bucket
      
        # The name of the project's settings. Always of the form: projects/`project-id`/
        # settings In update request: never set In response: always set
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @default_bucket = args[:default_bucket] if args.key?(:default_bucket)
          @name = args[:name] if args.key?(:name)
        end
      end
      
      # Request message for StepService.PublishXunitXmlFiles.
      class PublishXunitXmlFilesRequest
        include Google::Apis::Core::Hashable
      
        # URI of the Xunit XML files to publish. The maximum size of the file this
        # reference is pointing to is 50MB. Required.
        # Corresponds to the JSON property `xunitXmlFiles`
        # @return [Array<Google::Apis::ToolresultsV1beta3::FileReference>]
        attr_accessor :xunit_xml_files
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @xunit_xml_files = args[:xunit_xml_files] if args.key?(:xunit_xml_files)
        end
      end
      
      # A rectangular region.
      class RegionProto
        include Google::Apis::Core::Hashable
      
        # The height, in pixels. Always set.
        # Corresponds to the JSON property `heightPx`
        # @return [Fixnum]
        attr_accessor :height_px
      
        # The left side of the rectangle, in pixels. Always set.
        # Corresponds to the JSON property `leftPx`
        # @return [Fixnum]
        attr_accessor :left_px
      
        # The top of the rectangle, in pixels. Always set.
        # Corresponds to the JSON property `topPx`
        # @return [Fixnum]
        attr_accessor :top_px
      
        # The width, in pixels. Always set.
        # Corresponds to the JSON property `widthPx`
        # @return [Fixnum]
        attr_accessor :width_px
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @height_px = args[:height_px] if args.key?(:height_px)
          @left_px = args[:left_px] if args.key?(:left_px)
          @top_px = args[:top_px] if args.key?(:top_px)
          @width_px = args[:width_px] if args.key?(:width_px)
        end
      end
      
      # The storage for test results.
      class ResultsStorage
        include Google::Apis::Core::Hashable
      
        # A reference to a file.
        # Corresponds to the JSON property `resultsStoragePath`
        # @return [Google::Apis::ToolresultsV1beta3::FileReference]
        attr_accessor :results_storage_path
      
        # A reference to a file.
        # Corresponds to the JSON property `xunitXmlFile`
        # @return [Google::Apis::ToolresultsV1beta3::FileReference]
        attr_accessor :xunit_xml_file
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @results_storage_path = args[:results_storage_path] if args.key?(:results_storage_path)
          @xunit_xml_file = args[:xunit_xml_file] if args.key?(:xunit_xml_file)
        end
      end
      
      # Execution stats for a user-provided Robo script.
      class RoboScriptExecution
        include Google::Apis::Core::Hashable
      
        # The number of Robo script actions executed successfully.
        # Corresponds to the JSON property `successfulActions`
        # @return [Fixnum]
        attr_accessor :successful_actions
      
        # The total number of actions in the Robo script.
        # Corresponds to the JSON property `totalActions`
        # @return [Fixnum]
        attr_accessor :total_actions
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @successful_actions = args[:successful_actions] if args.key?(:successful_actions)
          @total_actions = args[:total_actions] if args.key?(:total_actions)
        end
      end
      
      # 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.
      class SafeHtmlProto
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `privateDoNotAccessOrElseSafeHtmlWrappedValue`
        # @return [String]
        attr_accessor :private_do_not_access_or_else_safe_html_wrapped_value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @private_do_not_access_or_else_safe_html_wrapped_value = args[:private_do_not_access_or_else_safe_html_wrapped_value] if args.key?(:private_do_not_access_or_else_safe_html_wrapped_value)
        end
      end
      
      # 
      class Screen
        include Google::Apis::Core::Hashable
      
        # File reference of the png file. Required.
        # Corresponds to the JSON property `fileReference`
        # @return [String]
        attr_accessor :file_reference
      
        # Locale of the device that the screenshot was taken on. Required.
        # Corresponds to the JSON property `locale`
        # @return [String]
        attr_accessor :locale
      
        # Model of the device that the screenshot was taken on. Required.
        # Corresponds to the JSON property `model`
        # @return [String]
        attr_accessor :model
      
        # OS version of the device that the screenshot was taken on. Required.
        # Corresponds to the JSON property `version`
        # @return [String]
        attr_accessor :version
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @file_reference = args[:file_reference] if args.key?(:file_reference)
          @locale = args[:locale] if args.key?(:locale)
          @model = args[:model] if args.key?(:model)
          @version = args[:version] if args.key?(:version)
        end
      end
      
      # 
      class ScreenshotCluster
        include Google::Apis::Core::Hashable
      
        # A string that describes the activity of every screen in the cluster.
        # Corresponds to the JSON property `activity`
        # @return [String]
        attr_accessor :activity
      
        # A unique identifier for the cluster. @OutputOnly
        # Corresponds to the JSON property `clusterId`
        # @return [String]
        attr_accessor :cluster_id
      
        # A singular screen that represents the cluster as a whole. This screen will act
        # as the "cover" of the entire cluster. When users look at the clusters, only
        # the key screen from each cluster will be shown. Which screen is the key screen
        # is determined by the ClusteringAlgorithm
        # Corresponds to the JSON property `keyScreen`
        # @return [Google::Apis::ToolresultsV1beta3::Screen]
        attr_accessor :key_screen
      
        # Full list of screens.
        # Corresponds to the JSON property `screens`
        # @return [Array<Google::Apis::ToolresultsV1beta3::Screen>]
        attr_accessor :screens
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @activity = args[:activity] if args.key?(:activity)
          @cluster_id = args[:cluster_id] if args.key?(:cluster_id)
          @key_screen = args[:key_screen] if args.key?(:key_screen)
          @screens = args[:screens] if args.key?(:screens)
        end
      end
      
      # Result summary for a shard in an environment.
      class ShardSummary
        include Google::Apis::Core::Hashable
      
        # Summaries of the steps belonging to the shard. With flaky_test_attempts
        # enabled from TestExecutionService, more than one run (Step) can present. And
        # the runs will be sorted by multistep_number.
        # Corresponds to the JSON property `runs`
        # @return [Array<Google::Apis::ToolresultsV1beta3::StepSummary>]
        attr_accessor :runs
      
        # Merged test result for environment. If the environment has only one step (no
        # reruns or shards), then the merged result is the same as the step result. If
        # the environment has multiple shards and/or reruns, then the results of shards
        # and reruns that belong to the same environment are merged into one environment
        # result.
        # Corresponds to the JSON property `shardResult`
        # @return [Google::Apis::ToolresultsV1beta3::MergedResult]
        attr_accessor :shard_result
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @runs = args[:runs] if args.key?(:runs)
          @shard_result = args[:shard_result] if args.key?(:shard_result)
        end
      end
      
      # Details for an outcome with a SKIPPED outcome summary.
      class SkippedDetail
        include Google::Apis::Core::Hashable
      
        # If the App doesn't support the specific API level.
        # Corresponds to the JSON property `incompatibleAppVersion`
        # @return [Boolean]
        attr_accessor :incompatible_app_version
        alias_method :incompatible_app_version?, :incompatible_app_version
      
        # If the App doesn't run on the specific architecture, for example, x86.
        # Corresponds to the JSON property `incompatibleArchitecture`
        # @return [Boolean]
        attr_accessor :incompatible_architecture
        alias_method :incompatible_architecture?, :incompatible_architecture
      
        # If the requested OS version doesn't run on the specific device model.
        # Corresponds to the JSON property `incompatibleDevice`
        # @return [Boolean]
        attr_accessor :incompatible_device
        alias_method :incompatible_device?, :incompatible_device
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @incompatible_app_version = args[:incompatible_app_version] if args.key?(:incompatible_app_version)
          @incompatible_architecture = args[:incompatible_architecture] if args.key?(:incompatible_architecture)
          @incompatible_device = args[:incompatible_device] if args.key?(:incompatible_device)
        end
      end
      
      # The details about how to run the execution.
      class Specification
        include Google::Apis::Core::Hashable
      
        # An Android mobile test specification.
        # Corresponds to the JSON property `androidTest`
        # @return [Google::Apis::ToolresultsV1beta3::AndroidTest]
        attr_accessor :android_test
      
        # A iOS mobile test specification
        # Corresponds to the JSON property `iosTest`
        # @return [Google::Apis::ToolresultsV1beta3::IosTest]
        attr_accessor :ios_test
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @android_test = args[:android_test] if args.key?(:android_test)
          @ios_test = args[:ios_test] if args.key?(:ios_test)
        end
      end
      
      # A stacktrace.
      class StackTrace
        include Google::Apis::Core::Hashable
      
        # The stack trace message. Required
        # Corresponds to the JSON property `exception`
        # @return [String]
        attr_accessor :exception
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @exception = args[:exception] if args.key?(:exception)
        end
      end
      
      # User provided intent failed to resolve to an activity.
      class StartActivityNotFound
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `action`
        # @return [String]
        attr_accessor :action
      
        # 
        # Corresponds to the JSON property `uri`
        # @return [String]
        attr_accessor :uri
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @action = args[:action] if args.key?(:action)
          @uri = args[:uri] if args.key?(:uri)
        end
      end
      
      # The `Status` type defines a logical error model that is suitable for different
      # programming environments, including REST APIs and RPC APIs. It is used by [
      # gRPC](https://github.com/grpc). Each `Status` message contains three pieces of
      # data: error code, error message, and error details. You can find out more
      # about this error model and how to work with it in the [API Design Guide](https:
      # //cloud.google.com/apis/design/errors).
      class Status
        include Google::Apis::Core::Hashable
      
        # The status code, which should be an enum value of google.rpc.Code.
        # Corresponds to the JSON property `code`
        # @return [Fixnum]
        attr_accessor :code
      
        # A list of messages that carry the error details. There is a common set of
        # message types for APIs to use.
        # Corresponds to the JSON property `details`
        # @return [Array<Hash<String,Object>>]
        attr_accessor :details
      
        # A developer-facing error message, which should be in English. Any user-facing
        # error message should be localized and sent in the google.rpc.Status.details
        # field, or localized by the client.
        # Corresponds to the JSON property `message`
        # @return [String]
        attr_accessor :message
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @code = args[:code] if args.key?(:code)
          @details = args[:details] if args.key?(:details)
          @message = args[:message] if args.key?(:message)
        end
      end
      
      # 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
      class Step
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `completionTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :completion_time
      
        # 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.
        # Corresponds to the JSON property `creationTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :creation_time
      
        # 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
        # Corresponds to the JSON property `description`
        # @return [String]
        attr_accessor :description
      
        # 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.
        # Corresponds to the JSON property `deviceUsageDuration`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :device_usage_duration
      
        # 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
        # Corresponds to the JSON property `dimensionValue`
        # @return [Array<Google::Apis::ToolresultsV1beta3::StepDimensionValueEntry>]
        attr_accessor :dimension_value
      
        # 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
        # Corresponds to the JSON property `hasImages`
        # @return [Boolean]
        attr_accessor :has_images
        alias_method :has_images?, :has_images
      
        # 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
        # Corresponds to the JSON property `labels`
        # @return [Array<Google::Apis::ToolresultsV1beta3::StepLabelsEntry>]
        attr_accessor :labels
      
        # Details when multiple steps are run with the same configuration as a group.
        # Corresponds to the JSON property `multiStep`
        # @return [Google::Apis::ToolresultsV1beta3::MultiStep]
        attr_accessor :multi_step
      
        # 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
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        # Interprets a result so that humans and machines can act on it.
        # Corresponds to the JSON property `outcome`
        # @return [Google::Apis::ToolresultsV1beta3::Outcome]
        attr_accessor :outcome
      
        # 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.
        # Corresponds to the JSON property `runDuration`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :run_duration
      
        # 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
        # Corresponds to the JSON property `state`
        # @return [String]
        attr_accessor :state
      
        # 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
        # Corresponds to the JSON property `stepId`
        # @return [String]
        attr_accessor :step_id
      
        # 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.
        # Corresponds to the JSON property `testExecutionStep`
        # @return [Google::Apis::ToolresultsV1beta3::TestExecutionStep]
        attr_accessor :test_execution_step
      
        # 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.
        # Corresponds to the JSON property `toolExecutionStep`
        # @return [Google::Apis::ToolresultsV1beta3::ToolExecutionStep]
        attr_accessor :tool_execution_step
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @completion_time = args[:completion_time] if args.key?(:completion_time)
          @creation_time = args[:creation_time] if args.key?(:creation_time)
          @description = args[:description] if args.key?(:description)
          @device_usage_duration = args[:device_usage_duration] if args.key?(:device_usage_duration)
          @dimension_value = args[:dimension_value] if args.key?(:dimension_value)
          @has_images = args[:has_images] if args.key?(:has_images)
          @labels = args[:labels] if args.key?(:labels)
          @multi_step = args[:multi_step] if args.key?(:multi_step)
          @name = args[:name] if args.key?(:name)
          @outcome = args[:outcome] if args.key?(:outcome)
          @run_duration = args[:run_duration] if args.key?(:run_duration)
          @state = args[:state] if args.key?(:state)
          @step_id = args[:step_id] if args.key?(:step_id)
          @test_execution_step = args[:test_execution_step] if args.key?(:test_execution_step)
          @tool_execution_step = args[:tool_execution_step] if args.key?(:tool_execution_step)
        end
      end
      
      # 
      class StepDimensionValueEntry
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `key`
        # @return [String]
        attr_accessor :key
      
        # 
        # Corresponds to the JSON property `value`
        # @return [String]
        attr_accessor :value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @key = args[:key] if args.key?(:key)
          @value = args[:value] if args.key?(:value)
        end
      end
      
      # 
      class StepLabelsEntry
        include Google::Apis::Core::Hashable
      
        # 
        # Corresponds to the JSON property `key`
        # @return [String]
        attr_accessor :key
      
        # 
        # Corresponds to the JSON property `value`
        # @return [String]
        attr_accessor :value
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @key = args[:key] if args.key?(:key)
          @value = args[:value] if args.key?(:value)
        end
      end
      
      # Lightweight summary of a step within this execution.
      class StepSummary
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Details for an outcome with a SUCCESS outcome summary. LINT.IfChange
      class SuccessDetail
        include Google::Apis::Core::Hashable
      
        # If a native process other than the app crashed.
        # Corresponds to the JSON property `otherNativeCrash`
        # @return [Boolean]
        attr_accessor :other_native_crash
        alias_method :other_native_crash?, :other_native_crash
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @other_native_crash = args[:other_native_crash] if args.key?(:other_native_crash)
        end
      end
      
      # 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.
      class SuggestionClusterProto
        include Google::Apis::Core::Hashable
      
        # Category in which these types of suggestions should appear. Always set.
        # Corresponds to the JSON property `category`
        # @return [String]
        attr_accessor :category
      
        # 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.
        # Corresponds to the JSON property `suggestions`
        # @return [Array<Google::Apis::ToolresultsV1beta3::SuggestionProto>]
        attr_accessor :suggestions
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @category = args[:category] if args.key?(:category)
          @suggestions = args[:suggestions] if args.key?(:suggestions)
        end
      end
      
      # 
      class SuggestionProto
        include Google::Apis::Core::Hashable
      
        # Reference to a help center article concerning this type of suggestion. Always
        # set.
        # Corresponds to the JSON property `helpUrl`
        # @return [String]
        attr_accessor :help_url
      
        # 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.
        # Corresponds to the JSON property `longMessage`
        # @return [Google::Apis::ToolresultsV1beta3::SafeHtmlProto]
        attr_accessor :long_message
      
        # Relative importance of a suggestion. Always set.
        # Corresponds to the JSON property `priority`
        # @return [String]
        attr_accessor :priority
      
        # 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.
        # Corresponds to the JSON property `pseudoResourceId`
        # @return [String]
        attr_accessor :pseudo_resource_id
      
        # A rectangular region.
        # Corresponds to the JSON property `region`
        # @return [Google::Apis::ToolresultsV1beta3::RegionProto]
        attr_accessor :region
      
        # Reference to a view element, identified by its resource name, if it has one.
        # Corresponds to the JSON property `resourceName`
        # @return [String]
        attr_accessor :resource_name
      
        # 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.
        # Corresponds to the JSON property `screenId`
        # @return [String]
        attr_accessor :screen_id
      
        # 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.
        # Corresponds to the JSON property `secondaryPriority`
        # @return [Float]
        attr_accessor :secondary_priority
      
        # 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.
        # Corresponds to the JSON property `shortMessage`
        # @return [Google::Apis::ToolresultsV1beta3::SafeHtmlProto]
        attr_accessor :short_message
      
        # General title for the suggestion, in the user's language, without markup.
        # Always set.
        # Corresponds to the JSON property `title`
        # @return [String]
        attr_accessor :title
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @help_url = args[:help_url] if args.key?(:help_url)
          @long_message = args[:long_message] if args.key?(:long_message)
          @priority = args[:priority] if args.key?(:priority)
          @pseudo_resource_id = args[:pseudo_resource_id] if args.key?(:pseudo_resource_id)
          @region = args[:region] if args.key?(:region)
          @resource_name = args[:resource_name] if args.key?(:resource_name)
          @screen_id = args[:screen_id] if args.key?(:screen_id)
          @secondary_priority = args[:secondary_priority] if args.key?(:secondary_priority)
          @short_message = args[:short_message] if args.key?(:short_message)
          @title = args[:title] if args.key?(:title)
        end
      end
      
      # 
      class TestCase
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `elapsedTime`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :elapsed_time
      
        # 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.
        # Corresponds to the JSON property `endTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :end_time
      
        # Why the test case was skipped. Present only for skipped test case
        # Corresponds to the JSON property `skippedMessage`
        # @return [String]
        attr_accessor :skipped_message
      
        # The stack trace details if the test case failed or encountered an error. The
        # maximum size of the stack traces is 100KiB, beyond which the stack track will
        # be truncated. Zero if the test case passed.
        # Corresponds to the JSON property `stackTraces`
        # @return [Array<Google::Apis::ToolresultsV1beta3::StackTrace>]
        attr_accessor :stack_traces
      
        # 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.
        # Corresponds to the JSON property `startTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :start_time
      
        # The status of the test case. Required.
        # Corresponds to the JSON property `status`
        # @return [String]
        attr_accessor :status
      
        # A unique identifier within a Step for this Test Case.
        # Corresponds to the JSON property `testCaseId`
        # @return [String]
        attr_accessor :test_case_id
      
        # 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.
        # Corresponds to the JSON property `testCaseReference`
        # @return [Google::Apis::ToolresultsV1beta3::TestCaseReference]
        attr_accessor :test_case_reference
      
        # References to opaque files of any format output by the tool execution. @
        # OutputOnly
        # Corresponds to the JSON property `toolOutputs`
        # @return [Array<Google::Apis::ToolresultsV1beta3::ToolOutputReference>]
        attr_accessor :tool_outputs
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @elapsed_time = args[:elapsed_time] if args.key?(:elapsed_time)
          @end_time = args[:end_time] if args.key?(:end_time)
          @skipped_message = args[:skipped_message] if args.key?(:skipped_message)
          @stack_traces = args[:stack_traces] if args.key?(:stack_traces)
          @start_time = args[:start_time] if args.key?(:start_time)
          @status = args[:status] if args.key?(:status)
          @test_case_id = args[:test_case_id] if args.key?(:test_case_id)
          @test_case_reference = args[:test_case_reference] if args.key?(:test_case_reference)
          @tool_outputs = args[:tool_outputs] if args.key?(:tool_outputs)
        end
      end
      
      # 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.
      class TestCaseReference
        include Google::Apis::Core::Hashable
      
        # The name of the class.
        # Corresponds to the JSON property `className`
        # @return [String]
        attr_accessor :class_name
      
        # The name of the test case. Required.
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        # The name of the test suite to which this test case belongs.
        # Corresponds to the JSON property `testSuiteName`
        # @return [String]
        attr_accessor :test_suite_name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @class_name = args[:class_name] if args.key?(:class_name)
          @name = args[:name] if args.key?(:name)
          @test_suite_name = args[:test_suite_name] if args.key?(:test_suite_name)
        end
      end
      
      # 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.
      class TestExecutionStep
        include Google::Apis::Core::Hashable
      
        # 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
        # Corresponds to the JSON property `testIssues`
        # @return [Array<Google::Apis::ToolresultsV1beta3::TestIssue>]
        attr_accessor :test_issues
      
        # 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)
        # Corresponds to the JSON property `testSuiteOverviews`
        # @return [Array<Google::Apis::ToolresultsV1beta3::TestSuiteOverview>]
        attr_accessor :test_suite_overviews
      
        # Testing timing break down to know phases.
        # Corresponds to the JSON property `testTiming`
        # @return [Google::Apis::ToolresultsV1beta3::TestTiming]
        attr_accessor :test_timing
      
        # An execution of an arbitrary tool. It could be a test runner or a tool copying
        # artifacts or deploying code.
        # Corresponds to the JSON property `toolExecution`
        # @return [Google::Apis::ToolresultsV1beta3::ToolExecution]
        attr_accessor :tool_execution
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @test_issues = args[:test_issues] if args.key?(:test_issues)
          @test_suite_overviews = args[:test_suite_overviews] if args.key?(:test_suite_overviews)
          @test_timing = args[:test_timing] if args.key?(:test_timing)
          @tool_execution = args[:tool_execution] if args.key?(:tool_execution)
        end
      end
      
      # An issue detected occurring during a test execution.
      class TestIssue
        include Google::Apis::Core::Hashable
      
        # Category of issue. Required.
        # Corresponds to the JSON property `category`
        # @return [String]
        attr_accessor :category
      
        # A brief human-readable message describing the issue. Required.
        # Corresponds to the JSON property `errorMessage`
        # @return [String]
        attr_accessor :error_message
      
        # Severity of issue. Required.
        # Corresponds to the JSON property `severity`
        # @return [String]
        attr_accessor :severity
      
        # A stacktrace.
        # Corresponds to the JSON property `stackTrace`
        # @return [Google::Apis::ToolresultsV1beta3::StackTrace]
        attr_accessor :stack_trace
      
        # Type of issue. Required.
        # Corresponds to the JSON property `type`
        # @return [String]
        attr_accessor :type
      
        # `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" `
        # Corresponds to the JSON property `warning`
        # @return [Google::Apis::ToolresultsV1beta3::Any]
        attr_accessor :warning
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @category = args[:category] if args.key?(:category)
          @error_message = args[:error_message] if args.key?(:error_message)
          @severity = args[:severity] if args.key?(:severity)
          @stack_trace = args[:stack_trace] if args.key?(:stack_trace)
          @type = args[:type] if args.key?(:type)
          @warning = args[:warning] if args.key?(:warning)
        end
      end
      
      # 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.
      class TestSuiteOverview
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `elapsedTime`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :elapsed_time
      
        # 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
        # Corresponds to the JSON property `errorCount`
        # @return [Fixnum]
        attr_accessor :error_count
      
        # 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
        # Corresponds to the JSON property `failureCount`
        # @return [Fixnum]
        attr_accessor :failure_count
      
        # 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.
        # Corresponds to the JSON property `flakyCount`
        # @return [Fixnum]
        attr_accessor :flaky_count
      
        # The name of the test suite. - In create/response: always set - In update
        # request: never
        # Corresponds to the JSON property `name`
        # @return [String]
        attr_accessor :name
      
        # 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
        # Corresponds to the JSON property `skippedCount`
        # @return [Fixnum]
        attr_accessor :skipped_count
      
        # Number of test cases, typically set by the service by parsing the xml_source. -
        # In create/response: always set - In update request: never
        # Corresponds to the JSON property `totalCount`
        # @return [Fixnum]
        attr_accessor :total_count
      
        # A reference to a file.
        # Corresponds to the JSON property `xmlSource`
        # @return [Google::Apis::ToolresultsV1beta3::FileReference]
        attr_accessor :xml_source
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @elapsed_time = args[:elapsed_time] if args.key?(:elapsed_time)
          @error_count = args[:error_count] if args.key?(:error_count)
          @failure_count = args[:failure_count] if args.key?(:failure_count)
          @flaky_count = args[:flaky_count] if args.key?(:flaky_count)
          @name = args[:name] if args.key?(:name)
          @skipped_count = args[:skipped_count] if args.key?(:skipped_count)
          @total_count = args[:total_count] if args.key?(:total_count)
          @xml_source = args[:xml_source] if args.key?(:xml_source)
        end
      end
      
      # Testing timing break down to know phases.
      class TestTiming
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `testProcessDuration`
        # @return [Google::Apis::ToolresultsV1beta3::Duration]
        attr_accessor :test_process_duration
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @test_process_duration = args[:test_process_duration] if args.key?(:test_process_duration)
        end
      end
      
      # A single thumbnail, with its size and format.
      class Thumbnail
        include Google::Apis::Core::Hashable
      
        # The thumbnail's content type, i.e. "image/png". Always set.
        # Corresponds to the JSON property `contentType`
        # @return [String]
        attr_accessor :content_type
      
        # The thumbnail file itself. That is, the bytes here are precisely the bytes
        # that make up the thumbnail file; they can be served as an image as-is (with
        # the appropriate content type.) Always set.
        # Corresponds to the JSON property `data`
        # NOTE: Values are automatically base64 encoded/decoded in the client library.
        # @return [String]
        attr_accessor :data
      
        # The height of the thumbnail, in pixels. Always set.
        # Corresponds to the JSON property `heightPx`
        # @return [Fixnum]
        attr_accessor :height_px
      
        # The width of the thumbnail, in pixels. Always set.
        # Corresponds to the JSON property `widthPx`
        # @return [Fixnum]
        attr_accessor :width_px
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @content_type = args[:content_type] if args.key?(:content_type)
          @data = args[:data] if args.key?(:data)
          @height_px = args[:height_px] if args.key?(:height_px)
          @width_px = args[:width_px] if args.key?(:width_px)
        end
      end
      
      # 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.
      class Timestamp
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `nanos`
        # @return [Fixnum]
        attr_accessor :nanos
      
        # 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.
        # Corresponds to the JSON property `seconds`
        # @return [Fixnum]
        attr_accessor :seconds
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @nanos = args[:nanos] if args.key?(:nanos)
          @seconds = args[:seconds] if args.key?(:seconds)
        end
      end
      
      # An execution of an arbitrary tool. It could be a test runner or a tool copying
      # artifacts or deploying code.
      class ToolExecution
        include Google::Apis::Core::Hashable
      
        # 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
        # Corresponds to the JSON property `commandLineArguments`
        # @return [Array<String>]
        attr_accessor :command_line_arguments
      
        # Exit code from a tool execution.
        # Corresponds to the JSON property `exitCode`
        # @return [Google::Apis::ToolresultsV1beta3::ToolExitCode]
        attr_accessor :exit_code
      
        # 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
        # Corresponds to the JSON property `toolLogs`
        # @return [Array<Google::Apis::ToolresultsV1beta3::FileReference>]
        attr_accessor :tool_logs
      
        # 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
        # Corresponds to the JSON property `toolOutputs`
        # @return [Array<Google::Apis::ToolresultsV1beta3::ToolOutputReference>]
        attr_accessor :tool_outputs
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @command_line_arguments = args[:command_line_arguments] if args.key?(:command_line_arguments)
          @exit_code = args[:exit_code] if args.key?(:exit_code)
          @tool_logs = args[:tool_logs] if args.key?(:tool_logs)
          @tool_outputs = args[:tool_outputs] if args.key?(:tool_outputs)
        end
      end
      
      # 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.
      class ToolExecutionStep
        include Google::Apis::Core::Hashable
      
        # An execution of an arbitrary tool. It could be a test runner or a tool copying
        # artifacts or deploying code.
        # Corresponds to the JSON property `toolExecution`
        # @return [Google::Apis::ToolresultsV1beta3::ToolExecution]
        attr_accessor :tool_execution
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @tool_execution = args[:tool_execution] if args.key?(:tool_execution)
        end
      end
      
      # Exit code from a tool execution.
      class ToolExitCode
        include Google::Apis::Core::Hashable
      
        # Tool execution exit code. A value of 0 means that the execution was successful.
        # - In response: always set - In create/update request: always set
        # Corresponds to the JSON property `number`
        # @return [Fixnum]
        attr_accessor :number
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @number = args[:number] if args.key?(:number)
        end
      end
      
      # A reference to a ToolExecution output file.
      class ToolOutputReference
        include Google::Apis::Core::Hashable
      
        # 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.
        # Corresponds to the JSON property `creationTime`
        # @return [Google::Apis::ToolresultsV1beta3::Timestamp]
        attr_accessor :creation_time
      
        # A reference to a file.
        # Corresponds to the JSON property `output`
        # @return [Google::Apis::ToolresultsV1beta3::FileReference]
        attr_accessor :output
      
        # 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.
        # Corresponds to the JSON property `testCase`
        # @return [Google::Apis::ToolresultsV1beta3::TestCaseReference]
        attr_accessor :test_case
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @creation_time = args[:creation_time] if args.key?(:creation_time)
          @output = args[:output] if args.key?(:output)
          @test_case = args[:test_case] if args.key?(:test_case)
        end
      end
      
      # A warning that the screen hierarchy is deeper than the recommended threshold.
      class UiElementTooDeep
        include Google::Apis::Core::Hashable
      
        # The depth of the screen element
        # Corresponds to the JSON property `depth`
        # @return [Fixnum]
        attr_accessor :depth
      
        # The screen id of the element
        # Corresponds to the JSON property `screenId`
        # @return [String]
        attr_accessor :screen_id
      
        # The screen state id of the element
        # Corresponds to the JSON property `screenStateId`
        # @return [String]
        attr_accessor :screen_state_id
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @depth = args[:depth] if args.key?(:depth)
          @screen_id = args[:screen_id] if args.key?(:screen_id)
          @screen_state_id = args[:screen_state_id] if args.key?(:screen_state_id)
        end
      end
      
      # Default unspecified warning.
      class UnspecifiedWarning
        include Google::Apis::Core::Hashable
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
        end
      end
      
      # Additional details of an unused robodirective.
      class UnusedRoboDirective
        include Google::Apis::Core::Hashable
      
        # The name of the resource that was unused.
        # Corresponds to the JSON property `resourceName`
        # @return [String]
        attr_accessor :resource_name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @resource_name = args[:resource_name] if args.key?(:resource_name)
        end
      end
      
      # This insight is a recommendation to upgrade a given library to the specified
      # version, in order to avoid dependencies on non-SDK APIs.
      class UpgradeInsight
        include Google::Apis::Core::Hashable
      
        # The name of the package to be upgraded.
        # Corresponds to the JSON property `packageName`
        # @return [String]
        attr_accessor :package_name
      
        # The suggested version to upgrade to. Optional: In case we are not sure which
        # version solves this problem
        # Corresponds to the JSON property `upgradeToVersion`
        # @return [String]
        attr_accessor :upgrade_to_version
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @package_name = args[:package_name] if args.key?(:package_name)
          @upgrade_to_version = args[:upgrade_to_version] if args.key?(:upgrade_to_version)
        end
      end
      
      # Additional details of a used Robo directive.
      class UsedRoboDirective
        include Google::Apis::Core::Hashable
      
        # The name of the resource that was used.
        # Corresponds to the JSON property `resourceName`
        # @return [String]
        attr_accessor :resource_name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @resource_name = args[:resource_name] if args.key?(:resource_name)
        end
      end
      
      # Additional details of a used Robo directive with an ignore action. Note: This
      # is a different scenario than unused directive.
      class UsedRoboIgnoreDirective
        include Google::Apis::Core::Hashable
      
        # The name of the resource that was ignored.
        # Corresponds to the JSON property `resourceName`
        # @return [String]
        attr_accessor :resource_name
      
        def initialize(**args)
           update!(**args)
        end
      
        # Update properties of this object
        def update!(**args)
          @resource_name = args[:resource_name] if args.key?(:resource_name)
        end
      end
    end
  end
end