├── .gitignore
├── features
    ├── __init__.py
    ├── pages
    │   ├── __init__.py
    │   ├── __pycache__
    │   │   ├── __init__.cpython-34.pyc
    │   │   ├── base_page.cpython-34.pyc
    │   │   ├── home_page.cpython-34.pyc
    │   │   ├── search_bar.cpython-34.pyc
    │   │   └── searching_page.cpython-34.pyc
    │   ├── home_page.py
    │   ├── search_bar.py
    │   ├── searching_page.py
    │   └── base_page.py
    ├── steps
    │   ├── __init__.py
    │   ├── home_page_steps.py
    │   └── searching_page_steps.py
    ├── test_scenarios
    │   ├── __init__.py
    │   ├── searching_page.feature
    │   └── home_page.feature
    ├── __init__.pyc
    ├── __pycache__
    │   └── __init__.cpython-34.pyc
    └── environment.py
├── myfile.json
├── project_video_link
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | 


--------------------------------------------------------------------------------
/features/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/features/pages/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/features/steps/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/features/test_scenarios/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/myfile.json:
--------------------------------------------------------------------------------
1 | {
2 |     "location":{
3 |         "url": "https://www.trivago.ie"
4 |     }
5 | }


--------------------------------------------------------------------------------
/features/__init__.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/__init__.pyc


--------------------------------------------------------------------------------
/project_video_link:
--------------------------------------------------------------------------------
1 | To see the project output on vide, please download:
2 | 
3 | https://app.box.com/s/h6xdpx7w0rb3lb1wokzlf3ppughxsa5j
4 | 


--------------------------------------------------------------------------------
/features/__pycache__/__init__.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/__pycache__/__init__.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/__pycache__/__init__.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/pages/__pycache__/__init__.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/__pycache__/base_page.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/pages/__pycache__/base_page.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/__pycache__/home_page.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/pages/__pycache__/home_page.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/__pycache__/search_bar.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/pages/__pycache__/search_bar.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/__pycache__/searching_page.cpython-34.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/crki76/Python-Behave-sample-project/HEAD/features/pages/__pycache__/searching_page.cpython-34.pyc


--------------------------------------------------------------------------------
/features/pages/home_page.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.common.by import By
 2 | 
 3 | from features.pages.base_page import BasePage
 4 | 
 5 | 
 6 | class HomePage(BasePage):
 7 | 
 8 |     project_url = "https://www.trivago.ie/"
 9 | 
10 |     local_directories = {
11 | 
12 |         "slogan": (
13 |             By.CLASS_NAME, 'hero__title'),
14 |         "filter_on_search_page": (
15 |             By.ID, 'js_filterlist')
16 | 
17 |     }


--------------------------------------------------------------------------------
/features/pages/search_bar.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.common.by import By
 2 | 
 3 | from features.pages.base_page import BasePage
 4 | 
 5 | 
 6 | class SearchBar(BasePage):
 7 | 
 8 |     local_directories = {
 9 |         "searching_bar": (
10 |             By.ID, 'horus-querytext'),
11 |         "searching_button": (
12 |             By.CLASS_NAME, 'horus-btn-search'),
13 | 
14 | 
15 |     }
16 | 
17 |     def insert_text_to_search_bar(self, text):
18 |         self.browser.find_element(*self.local_directories["searching_bar"]).send_keys(text)


--------------------------------------------------------------------------------
/features/pages/searching_page.py:
--------------------------------------------------------------------------------
 1 | from selenium.webdriver.common.by import By
 2 | 
 3 | from features.pages.base_page import BasePage
 4 | 
 5 | 
 6 | class SearchingPage(BasePage):
 7 | 
 8 |     local_directories = {
 9 |         "searching_filter": (
10 |             By.ID, 'js_filterlist'),
11 |         "option_wife": (
12 |             By.CSS_SELECTOR, "button[title='Free WiFi'] .fl-group__btn"),
13 |         "option_spa": (
14 |             By.CSS_SELECTOR, "button[title='Spa'] .fl-group__btn"),
15 |         "searching_area": (By.CLASS_NAME, 'name__copytext')
16 | 
17 | 
18 |     }
19 | 
20 | 


--------------------------------------------------------------------------------
/features/test_scenarios/searching_page.feature:
--------------------------------------------------------------------------------
 1 | Feature: Acting in Searching page as required
 2 | 
 3 | Scenario Outline: User inserts searching text to the searching engine and expects to be succeed
 4 |   Given I am redirected on home page
 5 |   When  I insert <insert_text> to search bar
 6 |   Then  I click on searching_button in search bar
 7 |   And   I ensure that <insert_text> is in <element>
 8 |   And   I click on <option>
 9 |   And   I check if my <option> is selected
10 |   Then  I expect <result> in searching_area for my searching of <insert_text> and <option>
11 |   Examples:
12 |   |insert_text                    |element            |option           |result |
13 |   |Cork International Hotel       |searching_bar      |option_wife      |True   |
14 |   |Jurys Inn Cork                 |searching_bar      |option_wife      |False  |
15 |   |The River Lee                  |searching_bar      |option_spa       |True   |
16 |   |Jurys Inn Cork                 |searching_bar      |option_spa       |False  |
17 | 
18 | 


--------------------------------------------------------------------------------
/features/test_scenarios/home_page.feature:
--------------------------------------------------------------------------------
 1 | Feature: Acting in trivago home page. Demonstrating some assertion and scooping methods
 2 | 
 3 |   Scenario Outline: User navigates to home page and observes page content
 4 |     Given I am redirected on home page
 5 |     When On page I want to see <element>
 6 |     Examples:
 7 |     |element          |
 8 |     |searching_bar    |
 9 |     |searching_button |
10 | 
11 |   Scenario: User navigates to home page and observes Trivago's slogan
12 |     Given I am redirected on home page
13 |     When In home page I want to see slogan
14 | 
15 | 
16 |   Scenario: User navigates to home page, clicks on search button and is redirected to searching page
17 |     Given I am redirected on home page
18 |     When I click on searching_button in search bar
19 |     Then In searching page I want to see searching_filter
20 | 
21 | # I use a regex for assertion as text was mark in the middle with end of the line special char
22 |   Scenario: User navigates to home page and wants to see a Trivago slogan
23 |     Given I am redirected on home page
24 |     When I want to see Find your ideal hotel|nfor the best price in slogan
25 | 
26 | 
27 | 
28 | 
29 | 
30 | 


--------------------------------------------------------------------------------
/features/steps/home_page_steps.py:
--------------------------------------------------------------------------------
 1 | from behave import *
 2 | from nose.tools import assert_equals, assert_true
 3 | import re
 4 | 
 5 | 
 6 | @given('I am redirected on home page')
 7 | def navigate_to_home_page(context):
 8 |     assert_equals(context.browser.current_url, "{}".format(
 9 |         context.home_page.project_url))
10 | 
11 | 
12 | @step('In home page I want to see {element_name}')
13 | def check_element_on_home_page(context, element_name):
14 |     can_see = context.home_page.wait_till_specific_element_is_not_displayed(
15 |         context.home_page.local_directories[element_name])
16 |     assert_true(can_see, "Element {} displayed on the page in the implicit time window".format(element_name))
17 | 
18 | 
19 | @step('In searching page I want to see {element_name}')
20 | def check_element_on_home_page(context, element_name):
21 |     can_see = context.searching_page.wait_till_specific_element_is_not_displayed(
22 |         context.searching_page.local_directories[element_name])
23 |     assert_true(can_see, "Element {} displayed on the page in the implicit time window".format(element_name))
24 | 
25 | 
26 | @step('On page I want to see {element_name}')
27 | def check_element_on_search_bar(context, element_name):
28 |     can_see = context.search_bar.wait_till_specific_element_is_not_displayed(
29 |         context.search_bar.local_directories[element_name])
30 |     assert_true(can_see, "Element {} displayed on the page in the implicit time window".format(element_name))
31 | 
32 | 
33 | @step('I click on {where} in search bar')
34 | def click_on_element_in_search_bar(context, where):
35 |     context.search_bar.click_on_element(where)
36 | 
37 | 
38 | @when ('I want to see {text} in {element}')
39 | def get_text_from_element(context, text, element):
40 |     element_text = context.home_page.get_text_from_element(element)
41 |     assert re.search(text, element_text)


--------------------------------------------------------------------------------
/features/steps/searching_page_steps.py:
--------------------------------------------------------------------------------
 1 | from behave import *
 2 | from nose.tools import assert_true, assert_equals
 3 | import time
 4 | 
 5 | 
 6 | @step('I insert {insert_text} to search bar')
 7 | def insert_text(context, insert_text):
 8 |     context.search_bar.wait_till_specific_element_is_not_displayed(
 9 |         context.search_bar.local_directories["searching_bar"])
10 |     context.search_bar.insert_text_to_search_bar(insert_text)
11 | 
12 | 
13 | @step('I ensure that {inserted_text} is in {element}')
14 | def check_text_in_the_element(context, inserted_text, element):
15 |     element_text = context.search_bar.get_attr_value(element)
16 |     assert(inserted_text in element_text)
17 | 
18 | 
19 | @then('I click on searching_button in search bar')
20 | def click_search_button(context):
21 |     context.search_bar.click_on_element("searching_button")
22 | 
23 | 
24 | @step('I click on {element}')
25 | def click_search_button(context, element):
26 |     time.sleep(5)
27 |     context.searching_page.wait_till_specific_element_is_not_displayed(
28 |         context.searching_page.local_directories[element])
29 |     context.searching_page.click_on_element(element)
30 | 
31 | 
32 | @step('I check if my {is_selected} is selected')
33 | def is_it_selected(context, is_selected):
34 |     check_it = context.searching_page.is_element_exists(is_selected)
35 |     assert_true(check_it)
36 | 
37 | 
38 | @step('I expect {result} in {element} for my searching of {inserted_text} and {option}')
39 | def final_searching_page_assertion(context, result, element, inserted_text, option):
40 |     container = context.searching_page.get_attr_title(element)
41 |     if inserted_text in container:
42 |         print("Searched object {} with option {} has been found".format(inserted_text, option))
43 |         search_result = "True"
44 |     else:
45 |         print("Object {} with option {} could not be found".format(inserted_text, option))
46 |         search_result = "False"
47 |     assert_equals(search_result, result)


--------------------------------------------------------------------------------
/features/pages/base_page.py:
--------------------------------------------------------------------------------
 1 | # from selenium.webdriver.common.action_chains import ActionChains
 2 | # from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.support.ui import WebDriverWait
 4 | from selenium.webdriver.support import expected_conditions as EC
 5 | import time
 6 | 
 7 | 
 8 | class BasePage(object):
 9 |     def __init__(self, browser, base_url):
10 |         self.browser = browser
11 |         self.base_url = base_url
12 |         self.timeout = 30
13 |         self.implicit_wait = 15
14 | 
15 |     def wait_till_specific_element_is_not_displayed(self, element):
16 |         try:
17 |             wait = WebDriverWait(self.browser, self.implicit_wait)
18 |             expected_element = EC.visibility_of_element_located(element)
19 |             wait.until(expected_element)
20 |             return True
21 |         except TimeoutError:
22 |             raise
23 | 
24 |     def click_on_element(self, element):
25 |         self.browser.find_element(*self.local_directories[element]).click()
26 | 
27 |     def get_text_from_element(self, element):
28 |         try:
29 |             a = self.browser.find_element(*self.local_directories[element])
30 |             time.sleep(1)
31 |         except KeyError:
32 |             print("Element {} does not exist".format(element))
33 |         text = a.text
34 |         return text
35 | 
36 |     def get_attr_value(self, element):
37 |         try:
38 |             a = self.browser.find_element(*self.local_directories[element])
39 |             time.sleep(1)
40 |         except KeyError:
41 |             print("Element {} does not exist".format(element))
42 |         text = a.get_attribute('value')
43 |         return text
44 | 
45 |     def get_attr_title(self, element):
46 |         try:
47 |             a = self.browser.find_element(*self.local_directories[element])
48 |             time.sleep(1)
49 |         except KeyError:
50 |             print("Element {} does not exist".format(element))
51 |         text = a.get_attribute('title')
52 |         return text
53 | 
54 |     def is_element_exists(self, element):
55 |         try:
56 |             self.browser.find_element(*self.local_directories[element])
57 |             time.sleep(1)
58 |             return 1
59 |         except KeyError:
60 |             print("Element {} does not exist".format(element))
61 |         return 0
62 | 
63 | 
64 | 


--------------------------------------------------------------------------------
/features/environment.py:
--------------------------------------------------------------------------------
 1 | from selenium import webdriver
 2 | from selenium.webdriver.common.by import By
 3 | from selenium.webdriver.support.ui import WebDriverWait
 4 | from selenium.webdriver.support import expected_conditions as EC
 5 | import json
 6 | 
 7 | from features.pages.home_page import HomePage
 8 | from features.pages.search_bar import SearchBar
 9 | from features.pages.searching_page import SearchingPage
10 | 
11 | import inspect
12 | 
13 | 
14 | # local dir used to wait for an element in main/home page
15 | local_directories = {
16 |     "searching_bar": (By.ID, 'horus-querytext')
17 | }
18 | # tuple used for wait element
19 | find_it = local_directories["searching_bar"]
20 | 
21 | # JSON preparation if more info stored in the config file
22 | # def load_json(json_file):
23 | #     data = load_file(json_file)
24 | #     json_data = json.loads(data)
25 | #     return json_data
26 | #
27 | #
28 | # def load_file(filename):
29 | #     with open(filename, 'r') as f:
30 | #         data = f.read()
31 | #     return data
32 | #
33 | # before all used when bigger project and data is read from JSON file
34 | # def before_all(context):
35 | #     context.env_file = "./myfile.json"
36 | #     context.env = load_json(context.env_file)
37 | #     if "location" in context.env.keys():
38 | #         context.location = context.env["location"]["url"]
39 | #         a = context.location
40 | #         print(a)
41 | 
42 | # before all scenario allows me to use always fresh browser without cache. Every time a new browser object is created
43 | 
44 | def before_scenario(context, scenario):
45 |     context.location = "https://www.trivago.ie"
46 |     option = webdriver.ChromeOptions()
47 |     option.add_argument("--start-maximized")
48 |     context.browser = webdriver.Chrome('/home/crki/git/kneat/chromedriver', chrome_options=option)
49 |     context.browser.get(context.location)
50 |     wait_for_click_element(context, find_it)
51 | 
52 |     context.home_page = HomePage(
53 |         context.browser, context.location)
54 |     context.search_bar = SearchBar(
55 |         context.browser, context.location)
56 |     context.searching_page = SearchingPage(
57 |         context.browser, context.location)
58 | 
59 | 
60 | def wait_for_click_element(context, find_it):
61 |     try:
62 |         wait = WebDriverWait(context.browser, 15)
63 |         expected_element = EC.element_to_be_clickable(find_it)
64 |         wait.until(expected_element)
65 |     except TimeoutError:
66 |         raise
67 | 
68 | 
69 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Python Behave sample project
  2 | Simple BDD test automation in frameworks: Behave framework, Selenium webdriver, Gherkin, Python(3.4). I used POM 
  3 | (page object modelling). Project uses a chromium driver (personally preffered slightly older version)
  4 | DOM elements found by using chrome inspector
  5 | 
  6 | 
  7 | Navigation in Trivago - REQUIREMENTS
  8 | ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  9 | Automation Code Challenge
 10 | 
 11 | Create a set of Selenium Tests in any programming language for the following requirements.
 12 | 
 13 | The website http://trivago.com/ have extended their search filters with some new options.
 14 | 
 15 | The new options are to filter on hotels with:
 16 | Free WiFi
 17 | Spa
 18 | 
 19 | Write tests to test these new filters.
 20 | 
 21 | Test data that can be used for this test includes:
 22 | 
 23 | Location: Cork
 24 | Dates: One night stay (3 months from today’s date)
 25 | Room: Double Room
 26 | 
 27 | Results expected:
 28 | Select Filter
 29 | Hotel Name
 30 | Is Listed
 31 | Free Wifi
 32 | Cork International Hotel
 33 | True
 34 | Free Wifi
 35 | Jurys Inn Cork
 36 | False
 37 | Spa
 38 | The River Lee
 39 | True
 40 | Spa
 41 | Jurys Inn Cork
 42 | False
 43 | 
 44 | Assume that hotels would be expected in the top results (paging does not need to be considered)
 45 | 
 46 | NOTE:
 47 | In your solution we are looking for good coding standards/practices for writing automated tests.
 48 | 
 49 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 50 | 
 51 | 
 52 | 
 53 | Dependencies on my .env
 54 | selenium
 55 | behave
 56 | webdriver
 57 | selenium
 58 | gherkin
 59 | parse
 60 | nose
 61 | 
 62 | Test OUTPUT
 63 | 
 64 | /home/crki/git/kneat/miso3/bin/python /home/crki/git/kneat/miso3/bin/behave -D BROWSER=chrome features/test_scenarios/
 65 | Feature: Acting in trivago home page. Demonstrating some assertion and scooping methods # features/test_scenarios/home_page.feature:1
 66 | 
 67 |   Scenario Outline: User navigates to home page and observes page content -- @1.1   # features/test_scenarios/home_page.feature:8
 68 |     Given I am redirected on home page                                              # features/steps/home_page_steps.py:6
 69 |     When On page I want to see searching_bar                                        # features/steps/home_page_steps.py:26
 70 | 
 71 |   Scenario Outline: User navigates to home page and observes page content -- @1.2   # features/test_scenarios/home_page.feature:9
 72 |     Given I am redirected on home page                                              # features/steps/home_page_steps.py:6
 73 |     When On page I want to see searching_button                                     # features/steps/home_page_steps.py:26
 74 | 
 75 |   Scenario: User navigates to home page and observes Trivago's slogan  # features/test_scenarios/home_page.feature:11
 76 |     Given I am redirected on home page                                 # features/steps/home_page_steps.py:6
 77 |     When In home page I want to see slogan                             # features/steps/home_page_steps.py:12
 78 | 
 79 |   Scenario: User navigates to home page, clicks on search button and is redirected to searching page  # features/test_scenarios/home_page.feature:16
 80 |     Given I am redirected on home page                                                                # features/steps/home_page_steps.py:6
 81 |     When I click on searching_button in search bar                                                    # features/steps/home_page_steps.py:33
 82 |     Then In searching page I want to see searching_filter                                             # features/steps/home_page_steps.py:19
 83 | 
 84 |   Scenario: User navigates to home page and wants to see a Trivago slogan  # features/test_scenarios/home_page.feature:22
 85 |     Given I am redirected on home page                                     # features/steps/home_page_steps.py:6
 86 |     When I want to see Find your ideal hotel|nfor the best price in slogan # features/steps/home_page_steps.py:38
 87 | 
 88 | Feature: Acting in Searching page as required # features/test_scenarios/searching_page.feature:1
 89 | 
 90 |   Scenario Outline: User inserts searching text to the searching engine and expects to be succeed -- @1.1   # features/test_scenarios/searching_page.feature:13
 91 |     Given I am redirected on home page                                                                      # features/steps/home_page_steps.py:6
 92 |     When I insert Cork International Hotel to search bar                                                    # features/steps/searching_page_steps.py:6
 93 |     Then I click on searching_button in search bar                                                          # features/steps/searching_page_steps.py:19
 94 |     And I ensure that Cork International Hotel is in searching_bar                                          # features/steps/searching_page_steps.py:13
 95 |     And I click on option_wife                                                                              # features/steps/searching_page_steps.py:24
 96 |     And I check if my option_wife is selected                                                               # features/steps/searching_page_steps.py:32
 97 |     Then I expect True in searching_area for my searching of Cork International Hotel and option_wife       # features/steps/searching_page_steps.py:40
 98 | 
 99 |   Scenario Outline: User inserts searching text to the searching engine and expects to be succeed -- @1.2   # features/test_scenarios/searching_page.feature:14
100 |     Given I am redirected on home page                                                                      # features/steps/home_page_steps.py:6
101 |     When I insert Jurys Inn Cork to search bar                                                              # features/steps/searching_page_steps.py:6
102 |     Then I click on searching_button in search bar                                                          # features/steps/searching_page_steps.py:19
103 |     And I ensure that Jurys Inn Cork is in searching_bar                                                    # features/steps/searching_page_steps.py:13
104 |     And I click on option_wife                                                                              # features/steps/searching_page_steps.py:24
105 |     And I check if my option_wife is selected                                                               # features/steps/searching_page_steps.py:32
106 |     Then I expect False in searching_area for my searching of Jurys Inn Cork and option_wife                # features/steps/searching_page_steps.py:40
107 | 
108 |   Scenario Outline: User inserts searching text to the searching engine and expects to be succeed -- @1.3   # features/test_scenarios/searching_page.feature:15
109 |     Given I am redirected on home page                                                                      # features/steps/home_page_steps.py:6
110 |     When I insert The River Lee to search bar                                                               # features/steps/searching_page_steps.py:6
111 |     Then I click on searching_button in search bar                                                          # features/steps/searching_page_steps.py:19
112 |     And I ensure that The River Lee is in searching_bar                                                     # features/steps/searching_page_steps.py:13
113 |     And I click on option_spa                                                                               # features/steps/searching_page_steps.py:24
114 |     And I check if my option_spa is selected                                                                # features/steps/searching_page_steps.py:32
115 |     Then I expect True in searching_area for my searching of The River Lee and option_spa                   # features/steps/searching_page_steps.py:40
116 | 
117 |   Scenario Outline: User inserts searching text to the searching engine and expects to be succeed -- @1.4   # features/test_scenarios/searching_page.feature:16
118 |     Given I am redirected on home page                                                                      # features/steps/home_page_steps.py:6
119 |     When I insert Jurys Inn Cork to search bar                                                              # features/steps/searching_page_steps.py:6
120 |     Then I click on searching_button in search bar                                                          # features/steps/searching_page_steps.py:19
121 |     And I ensure that Jurys Inn Cork is in searching_bar                                                    # features/steps/searching_page_steps.py:13
122 |     And I click on option_spa                                                                               # features/steps/searching_page_steps.py:24
123 |     And I check if my option_spa is selected                                                                # features/steps/searching_page_steps.py:32
124 |     Then I expect False in searching_area for my searching of Jurys Inn Cork and option_spa                 # features/steps/searching_page_steps.py:40
125 | 
126 | 2 features passed, 0 failed, 0 skipped
127 | 9 scenarios passed, 0 failed, 0 skipped
128 | 39 steps passed, 0 failed, 0 skipped, 0 undefined
129 | Took 0m52.643s
130 | 
131 | Process finished with exit code 0
132 | 
133 | 
134 | 
135 | 


--------------------------------------------------------------------------------