rsmp-validator 0.1.0

data/test/site/tlc/emergency_routes_spec.rb

@@ -0,0 +1,106 @@
+describe 'Site::Tlc::EmergencyRoutes' do
+  include RSMP::Validator::Helpers::Status
+
+  # Verify that current emergency route can be read with S0006.
+  # Depreciated from 1.2, use S0035 instead.
+  # 1. Given the site_proxy is connected.
+  # 2. When we request S0006.
+  # 3. Then we should receive a status response.
+  it 'emergency route is read with S0006' do
+    with_site(:connected, sxl: ['>=1.0.7', '<1.2']) do |site_proxy|
+      site_proxy.request_status_and_collect({ S0006: %i[status emergencystage] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that current emergency routes can be read with S0035.
+  # Requires core >= 3.2 since it uses the array data type.
+  # 1. Given the site_proxy is connected.
+  # 2. When we request S0035.
+  # 3. Then we should receive a status response.
+  it 'emergency route is read with S0035' do
+    skip 'requires core >= 3.2' unless RSMP::Validator.core_matches?('>=3.2')
+    with_site(:connected, sxl: '>=1.2') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0035: [:emergencyroutes] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that emergency routes can be activated with M0005.
+  # S0006 should reflect the last route enabled/disabled.
+  # 1. Given the site_proxy is connected.
+  # 2. When we send M0005 to set emergency route.
+  # 3. Then we should get a command responds confirming the change.
+  it 'can be activated with M0005 and read with S0006' do
+    skip 'requires sxl >= 1.0.7, < 1.2' unless RSMP::Validator.sxl_matches?(['>=1.0.7', '<1.2'])
+    emergency_routes = RSMP::Validator.get_config('items', 'emergency_routes')
+    skip('No emergency routes configured') if emergency_routes.nil? || emergency_routes.empty?
+
+    def set_emergency_states(site_proxy, emergency_routes, state)
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      emergency_routes.each do |emergency_route|
+        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: state, within: timeout)
+      end
+      wait_for_status(site_proxy, "emergency route #{emergency_routes.last} to be enabled",
+                      [
+                        { 'sCI' => 'S0006', 'n' => 'status', 's' => (state ? 'True' : 'False') },
+                        { 'sCI' => 'S0006', 'n' => 'emergencystage',
+                          's' => (state ? emergency_routes.last.to_s : '0') }
+                      ])
+    end
+
+    with_site(:connected) do |site_proxy|
+      set_emergency_states(site_proxy, emergency_routes, false)
+      begin
+        set_emergency_states(site_proxy, emergency_routes, true)
+      ensure
+        set_emergency_states(site_proxy, emergency_routes, false)
+      end
+    end
+  end
+
+  # Verify that emergency routes can be activated with M0005.
+  # S0035 should show all active routes.
+  # 1. Given the site_proxy is connected.
+  # 2. When we send M0005 to set emergency route.
+  # 3. Then we should get a command responds confirming the change.
+  # 4. When we request the current emergency routes with S035.
+  # 5. Then we should receive the list of active routes.
+
+  it 'emergency routes can be activated with M0005 and read with S0035' do
+    skip 'requires core >= 3.2' unless RSMP::Validator.core_matches?('>=3.2')
+    skip 'requires sxl >= 1.2' unless RSMP::Validator.sxl_matches?('>=1.2')
+
+    emergency_routes = RSMP::Validator.get_config('items', 'emergency_routes')
+    skip('No emergency routes configured') if emergency_routes.nil? || emergency_routes.empty?
+
+    def enable_routes(site_proxy, emergency_routes)
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      emergency_routes.each do |emergency_route|
+        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: true, within: timeout)
+      end
+      routes = emergency_routes.map { |i| { 'id' => i.to_s } }
+      wait_for_status(site_proxy, "emergency routes #{emergency_routes} to be enabled",
+                      [{ 'sCI' => 'S0035', 'n' => 'emergencyroutes', 's' => routes }])
+    end
+
+    def disable_routes(site_proxy, emergency_routes, within:)
+      emergency_routes.each do |emergency_route|
+        site_proxy.tlc.set_emergency_route(route: emergency_route.to_s, active: false, within:)
+      end
+      routes = []
+      wait_for_status(site_proxy, 'all emergency routes to be disabled',
+                      [{ 'sCI' => 'S0035', 'n' => 'emergencyroutes', 's' => routes }])
+    end
+
+    with_site(:connected) do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      disable_routes(site_proxy, emergency_routes, within: timeout)
+      begin
+        enable_routes(site_proxy, emergency_routes)
+      ensure
+        disable_routes(site_proxy, emergency_routes, within: timeout)
+      end
+    end
+  end
+end

data/test/site/tlc/input_spec.rb

@@ -0,0 +1,102 @@
+describe 'Site::Tlc::Input' do
+  include RSMP::Validator::Helpers::Input
+
+  # Tests related to inputs and outputs.
+
+  # Verify that we can read input status with S0003, extendedinputstatus attribute
+  # 1. Given the site is connected
+  # 2. When we read input with S0029
+  # 3. Then we should receive a valid response
+  it 'is read with S0003 with extended input status' do
+    with_site(:connected, sxl: '<1.2') do |site_proxy|
+      site_proxy.request_status_and_collect(
+        { S0003: %i[inputstatus extendedinputstatus] },
+        within: RSMP::Validator.get_config('timeouts', 'status_response')
+      ).ok!
+    end
+  end
+
+  # Verify that we can read input status with S0003
+  # 1. Given the site is connected
+  # 2. When we read input with S0029
+  # 3. Then we should receive a valid response
+  it 'is read with S0003' do
+    with_site(:connected, sxl: '>=1.2') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0003: [:inputstatus] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can read forced input status with S0029
+  # 1. Given the site is connected
+  # 2. When we read input with S0029
+  # 3. Then we should receive a valid response
+  it 'forcing is read with S0029' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0029: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can force input with M0019
+  # 1. Given the site is connected
+  # 2. And the input is forced off
+  # 2. When we force the input on
+  # 3. Then S0003 should show the input on
+
+  it 'forcing is set with M0019' do
+    with_site(:connected, sxl: '>=1.0.13') do |site_proxy|
+      inputs = RSMP::Validator.get_config('items', 'inputs')
+      skip('No inputs configured') if inputs.nil? || inputs.empty?
+      inputs.each do |input|
+        timeout = RSMP::Validator.get_config('timeouts', 'command')
+        site_proxy.tlc.force_input(input: input, status: 'True', value: 'False', within: timeout)
+        site_proxy.tlc.force_input(input: input, status: 'True', value: 'True', within: timeout)
+      ensure
+        site_proxy.tlc.force_input(input: input, status: 'False', value: 'True', within: timeout)
+      end
+    end
+  end
+
+  # Verify that we can activate input with M0006
+  # 1. Given the site is connected
+  # 2. When we activate input with M0006
+  # 3. Then S0003 should show the input is active
+  # 4. When we deactivate input with M0006
+  # 5. Then S0003 should show the input is inactive
+
+  it 'is activated with M0006' do
+    inputs = RSMP::Validator.get_config('items', 'inputs')
+    skip('No inputs configured') if inputs.nil? || inputs.empty?
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      inputs.each { |input| switch_input(site_proxy, input, within: timeout) }
+    end
+  end
+
+  # Verify that we can acticate/deactivate a series of inputs with M0013
+  # 1. Given the site is connected
+  # 2. Send control command to set a serie of input
+  # 3. Wait for status = true
+  it 'series is activated with M0013' do
+    with_site(:connected, sxl: '>=1.0.8') do |site_proxy|
+      inputs = RSMP::Validator.get_config('items', 'inputs')
+      skip('No inputs configured') if inputs.nil? || inputs.empty?
+      status = '1,3,12;5,5,10'
+      timeout = RSMP::Validator.get_config('timeouts', 'command')
+      site_proxy.tlc.set_inputs(status, within: timeout)
+    end
+  end
+
+  # Verify that input sensitivity can be set with M0021
+  # 1. Given the site is connected
+  # 2. When we set sensitivity with M0021
+  # 3. Then we receive a confirmation
+  it 'sensitivity is set with M0021' do
+    with_site(:connected, sxl: '>=1.0.15') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      status = '1-50'
+      site_proxy.tlc.set_trigger_level(status, within: timeout)
+    end
+  end
+end

data/test/site/tlc/invalid_command_spec.rb

@@ -0,0 +1,103 @@
+describe 'Site::Tlc::InvalidCommand' do
+  # Verify that site_proxy reponds with age=undefined when receiving
+  # a command with an unknown component id
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a command with an unknown component id
+  # 3. Then the site_proxy should return a command response with age=undefined
+
+  it 'returns a command response with age=undefined if compoent id is unknown' do
+    with_site(:connected, core: '>=3.1.3') do |site_proxy|
+      log 'Sending M0001'
+      command_list = RSMP::CommandList.new(:M0001, :setValue,
+                                           securityCode: RSMP::Validator.get_config('secrets', 'security_codes', 2),
+                                           status: 'NormalControl',
+                                           timeout: 0,
+                                           intersection: 0).to_a
+      result = site_proxy.send_command_and_collect(
+        command_list,
+        component: 'bad',
+        within: RSMP::Validator.get_config('timeouts', 'command_response'),
+        validate: false # disable validation of outgoing message
+      )
+      expect(result).to be_a(RSMP::Collector)
+      expect(result.status).to eq(:ok)
+      response = result.messages.first
+      expect(response).to be_a(RSMP::CommandResponse)
+      rvs = response.attributes['rvs']
+      expect(rvs).to be_a(Array)
+      rvs.each do |rv|
+        age = rv['age']
+        expect(age).to eq('undefined')
+      end
+    end
+  end
+
+  # Verify that site_proxy returns NotAck when receiving an unknown command
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a non-existing M0000 command
+  # 3. Then the site_proxy should return NotAck
+
+  it 'returns NotAck if command code id is unknown' do
+    with_site(:connected) do |site_proxy|
+      log 'Sending non-existing command M0000'
+      command_list = RSMP::CommandList.new(:M0000, :bad, {}).to_a
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+
+      collector = site_proxy.send_command_and_collect(command_list,
+                                                      within: timeout,
+                                                      validate: false) # disable schema validation of outgoing message
+      expect(collector.status).to eq(:cancelled)
+      expect(collector.error).to be_a(RSMP::MessageRejected)
+    end
+  end
+
+  # Verify that site_proxy returns NotAck when receiving a command
+  # with a mising command attribute
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send an M0001 command with 'status' missing
+  # 3. Then the site_proxy return NotAck
+
+  it 'returns NotAck if attribute is missing' do
+    with_site(:connected) do |site_proxy|
+      log "Sending M0001 with 'status' attribute missing"
+      command_list = RSMP::CommandList.new(:M0001, :setValue,
+                                           securityCode: '1111',
+                                           intersection: '0',
+                                           timeout: '0').to_a
+      # intentionally not setting 'status'
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      collector = site_proxy.send_command_and_collect(command_list,
+                                                      within: timeout,
+                                                      validate: false) # disable validation of outgoing message
+      expect(collector.status).to eq(:cancelled)
+      expect(collector.error).to be_a(RSMP::MessageRejected)
+    end
+  end
+
+  # Verify that site_proxy returns NotAck when receiving a command
+  # with an unknown command name
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send an M0001 command with 'bad' as command name
+  # 3. Then the site_proxy should return NotAck
+
+  it 'returns NotAck if command name is bad' do
+    with_site(:connected) do |site_proxy|
+      log 'Sending M0001'
+      # for M0001, cO should be :setValue, here we use the incorrect :bad
+      command_list = RSMP::CommandList.new(:M0001, :bad,
+                                           securityCode: '1111',
+                                           intersection: '0',
+                                           timeout: '0').to_a
+      timeout = RSMP::Validator.get_config('timeouts', 'command_response')
+      collector = site_proxy.send_command_and_collect(command_list,
+                                                      within: timeout,
+                                                      validate: false) # disable validation of outgoing message
+      expect(collector.status).to eq(:cancelled)
+      expect(collector.error).to be_a(RSMP::MessageRejected)
+    end
+  end
+end

data/test/site/tlc/invalid_status_spec.rb

@@ -0,0 +1,70 @@
+describe 'Site::Tlc::InvalidStatus' do
+  # Verify that site_proxy reponds with q=undefined when receiving a
+  # status request with an unknown component id.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a status request with an unknown component id
+  # 3. Then the site_proxy should return a status response with q=undefined
+
+  it 'return a command response with age=undefined when component id is unknown' do
+    with_site(:connected, core: '>=3.1.3') do |site_proxy|
+      log 'Sending M0001 with bad component id'
+      collector = site_proxy.request_status_and_collect(
+        { S0001: [:signalgroupstatus] },
+        component: 'bad',
+        within: RSMP::Validator.get_config('timeouts', 'status_response'),
+        validate: false
+      )
+      collector.ok!
+      expect(collector.status).to eq(:ok)
+      response = collector.messages.first
+      expect(response).to be_a(RSMP::StatusResponse)
+      ss = response.attributes['sS']
+      expect(ss).to be_a(Array)
+      ss.each do |s|
+        q = s['q']
+        expect(q).to eq('undefined')
+      end
+    end
+  end
+
+  # Verify that site_proxy returns NotAck when receiving
+  # a request for an unknown status
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send a non-existing S000 status request
+  # 3. Then the site_proxy should return NotAck
+  it 'returns NotAck when status code is unknown' do
+    with_site(:connected) do |site_proxy|
+      log 'Requesting non-existing status S0000'
+      expect do
+        site_proxy.request_status_and_collect(
+          { S0000: [:status] },
+          component: RSMP::Validator.get_config('main_component'),
+          within: RSMP::Validator.get_config('timeouts', 'status_response'),
+          validate: false
+        ).ok!
+      end.to raise_exception(RSMP::MessageRejected)
+    end
+  end
+
+  # Verify that site_proxy returns NotAck when receiving
+  # a request for an unknown status
+  #
+  # 1. Given the site_proxy is connected
+  # 2. When we send an S0001 request with the stauts name 'bad'
+  # 3. Then the site_proxy should return NotAck
+  it 'returns NotAck when status name is unknown' do
+    with_site(:connected) do |site_proxy|
+      log 'Requesting S0001 with non-existing status name'
+      expect do
+        site_proxy.request_status_and_collect(
+          { S0001: [:bad] },
+          component: RSMP::Validator.get_config('main_component'),
+          within: RSMP::Validator.get_config('timeouts', 'status_response'),
+          validate: false
+        ).ok!
+      end.to raise_exception(RSMP::MessageRejected)
+    end
+  end
+end

data/test/site/tlc/modes_spec.rb

@@ -0,0 +1,260 @@
+describe 'Site::Tlc::Modes' do
+  include RSMP::Validator::Helpers::Startup
+
+  # Verify status S0020 control mode
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'control mode is read with S0020' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0020: %i[controlmode intersection] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0005 traffic controller starting
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'startup status is read with S0005' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0005: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0005 traffic controller starting by intersection
+  # statusByIntersection requires core >= 3.2, since it uses the array data type.
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'startup status is read with S0005 by intersection' do
+    skip 'requires core >= 3.2' unless RSMP::Validator.core_matches?('>=3.2')
+    with_site(:connected, sxl: '>=1.2') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0005: [:statusByIntersection] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0007 controller switched on (dark mode=off)
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'switched on is read with S0007' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0007: %i[status intersection] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0007 controller switched on, source attribute
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'switched on is read with S0007 with source' do
+    with_site(:connected, sxl: '>=1.1') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0007: %i[status intersection source] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0008 manual control
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'manual control is read with S0008' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0008: %i[status intersection source] }
+                    else
+                      { S0008: %i[status intersection] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0009 fixed time control
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'fixed time control is read with S0009' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0009: %i[status intersection source] }
+                    else
+                      { S0009: %i[status intersection] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify command M0007 fixed time control
+  #
+  # 1. Verify connection
+  # 2. Send command to switch to fixed time = true
+  # 3. Wait for status = true
+  # 4. Send command to switch to fixed time = false
+  # 5. Wait for status = false
+  it 'fixed time control can be activated with M0007' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'command')
+      site_proxy.tlc.set_fixed_time('True', within: timeout)
+      site_proxy.tlc.set_fixed_time('False', within: timeout)
+    end
+  end
+
+  # Verify status S0010 isolated control
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'isolated control is read with S0010' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0010: %i[status intersection source] }
+                    else
+                      { S0010: %i[status intersection] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0032 coordinated control
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'coordinated control is read with S0032' do
+    with_site(:connected, sxl: '>=1.1') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0032: %i[status intersection source] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0011 yellow flash
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'yellow flash can be read with S0011' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0011: %i[status intersection source] }
+                    else
+                      { S0011: %i[status intersection] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can activate yellow flash
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send the control command to switch to Yellow flash
+  # 3. Wait for status Yellow flash
+  # 4. Send command to switch to normal control
+  # 5. Wait for status "Yellow flash" = false, "Controller starting"= false, "Controller on"= true"
+  it 'yellow flash can be activated with M0001' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      yellow_flash_timeout = RSMP::Validator.get_config('timeouts', 'yellow_flash')
+      startup_timeout = RSMP::Validator.get_config('timeouts', 'startup_sequence')
+      site_proxy.tlc.set_functional_position('YellowFlash', within: yellow_flash_timeout)
+      site_proxy.tlc.set_functional_position('NormalControl', within: startup_timeout)
+    end
+  end
+
+  # Verify that we can yellow flash causes all groups to go to state 'c'
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send the control command to switch to Yellow flash
+  # 3. Wait for all groups to go to group 'c'
+  # 4. Send command to switch to normal control
+  # 5. Wait for all groups to switch do something else that 'c'
+  it 'yellow flash affects all signal groups' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'yellow_flash')
+
+      site_proxy.tlc.set_functional_position('YellowFlash', within: timeout)
+      site_proxy.tlc.wait_for_groups 'c', timeout: timeout      # c means yellow flash
+
+      startup_timeout = RSMP::Validator.get_config('timeouts', 'startup_sequence')
+      site_proxy.tlc.set_functional_position('NormalControl', within: startup_timeout)
+      site_proxy.tlc.wait_for_groups '[^c]', timeout: timeout   # not c, ie. not yellow flash
+    end
+  end
+
+  # Verify status S0012 all red
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'all red can be read with S0012' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      status_list = if RSMP::Proxy.version_meets_requirement?(site_proxy.sxl_version, '>=1.1')
+                      { S0012: %i[status intersection source] }
+                    else
+                      { S0012: %i[status intersection] }
+                    end
+      site_proxy.request_status_and_collect(status_list,
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify status S0013 police key
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Request status
+  # 3. Expect status response before timeout
+  it 'police key can be read with S0013' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      site_proxy.request_status_and_collect({ S0013: [:status] },
+                                            within: RSMP::Validator.get_config('timeouts', 'status_response')).ok!
+    end
+  end
+
+  # Verify that we can activate dark mode
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send the control command to switch todarkmode
+  # 3. Wait for status"Controller on" = false
+  # 4. Send command to switch to normal control
+  # 5. Wait for status "Yellow flash" = false, "Controller starting"= false, "Controller on"= true"
+  it 'dark mode can be activated with M0001' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      timeout = RSMP::Validator.get_config('timeouts', 'functional_position')
+      startup_timeout = RSMP::Validator.get_config('timeouts', 'startup_sequence')
+      site_proxy.tlc.set_functional_position('Dark', within: timeout)
+      site_proxy.tlc.set_functional_position('NormalControl', within: startup_timeout)
+    end
+  end
+
+  # Verify that we can activate yellow flash and after 1 minute goes back to NormalControl
+  #
+  # 1. Given the site_proxy is connected
+  # 2. Send the control command to switch to Normal Control, and wait for this
+  # 2. Send the control command to switch to Yellow flash
+  # 3. Wait for status Yellow flash
+  # 5. Wait for automatic revert to Normal Control
+  it 'can use yellow flash with a timeout of one minute' do
+    with_site(:connected, sxl: '>=1.0.7') do |site_proxy|
+      startup_timeout = RSMP::Validator.get_config('timeouts', 'startup_sequence')
+      site_proxy.tlc.set_functional_position('NormalControl', within: startup_timeout)
+      minutes = 1
+      timeout = RSMP::Validator.get_config('timeouts', 'yellow_flash')
+      site_proxy.tlc.set_functional_position('YellowFlash', timeout_minutes: minutes, within: timeout)
+      fp_timeout = RSMP::Validator.get_config('timeouts', 'functional_position')
+      wait_normal_control(site_proxy, timeout: (minutes * 60) + fp_timeout)
+    end
+  end
+end