Merge branch 'master' into WIFI-3516

2025-11-02 03:48:09 +00:00 · 2021-08-27 14:47:04 +05:30
parent b0a19ba86a fd58529a16
commit 7e2be56b00
40 changed files with 2858 additions and 378 deletions
--- a/.github/workflows/manual.yml
+++ b/.github/workflows/manual.yml
@@ -116,7 +116,7 @@ jobs:
                  - -c
                  - |
                    cd tests
-                    pytest -m "performance and ${{ github.event.inputs.marker_expression }}" -s -vvv --testbed="${{ github.event.inputs.testbed }}" --skip-testrail --alluredir=/tmp/allure-results "${{ github.event.inputs.additional_args }}"
+                    pytest -m "${{ github.event.inputs.marker_expression }}" -s -vvv --testbed="${{ github.event.inputs.testbed }}" --skip-testrail --alluredir=/tmp/allure-results "${{ github.event.inputs.additional_args }}"
                    ret=\$?
                    # sleep some time to be able to download the Allure results
                    sleep 60
--- a/.github/workflows/performance.yml
+++ b/.github/workflows/performance.yml
@@ -255,7 +255,7 @@ jobs:
      run: |
        mkdir -p allure-report/results
        cp -r allure-results-dataplane_throughput_test allure-report/results
-        cp -r allure-results-single_station_dual_band_throughput/results
+        cp -r allure-results-single_station_dual_band_throughput allure-report/results
        cp -r allure-results-wifi_capacity_test allure-report/results
    - name: copy new report
      run: |
--- a/.github/workflows/test-ucentral-deployment.yaml
+++ b/.github/workflows/test-ucentral-deployment.yaml
@@ -70,19 +70,21 @@ jobs:
      env:
        TOFILL: YES
      run: |
-        export NAMESPACE="ucentral-$GITHUB_RUN_ID"
-        export DEPLOY_METHOD="${{ github.event.inputs.deploy_method }}"
-        export CHART_VERSION="${{ github.event.inputs.chart_version }}"
-        export UCENTRALGW_VERSION="${{ github.event.inputs.ucentralgw_version }}"
-        export UCENTRALGWUI_VERSION="${{ github.event.inputs.ucentralgwui_version }}"
-        export UCENTRALSEC_VERSION="${{ github.event.inputs.ucentralsec_version }}"
-        export UCENTRALFMS_VERSION="${{ github.event.inputs.ucentralfms_version }}"
+        export NAMESPACE=ucentral-$GITHUB_RUN_ID
+        export DEPLOY_METHOD=${{ github.event.inputs.deploy_method }}
+        export CHART_VERSION=${{ github.event.inputs.chart_version }}
+        export UCENTRALGW_VERSION=${{ github.event.inputs.ucentralgw_version }}
+        export UCENTRALGWUI_VERSION=${{ github.event.inputs.ucentralgwui_version }}
+        export UCENTRALSEC_VERSION=${{ github.event.inputs.ucentralsec_version }}
+        export UCENTRALFMS_VERSION=${{ github.event.inputs.ucentralfms_version }}
        export VALUES_FILE_LOCATION=values.ucentral-qa.yaml
-        export RTTY_TOKEN="${{ secrets.RTTY_TOKEN }}"
-        export UCENTRALGW_AUTH_USERNAME="${{ secrets.UCENTRALGW_AUTH_USERNAME }}"
-        export UCENTRALGW_AUTH_PASSWORD="${{ secrets.UCENTRALGW_AUTH_PASSWORD }}"
-        export UCENTRALFMS_S3_SECRET="${{ secrets.UCENTRALFMS_S3_SECRET }}"
-        export UCENTRALFMS_S3_KEY="${{ secrets.UCENTRALFMS_S3_KEY }}"
+        export RTTY_TOKEN=${{ secrets.RTTY_TOKEN }}
+        export UCENTRALGW_AUTH_USERNAME=${{ secrets.UCENTRALGW_AUTH_USERNAME }}
+        export UCENTRALGW_AUTH_PASSWORD=${{ secrets.UCENTRALGW_AUTH_PASSWORD }}
+        export UCENTRALFMS_S3_SECRET=${{ secrets.UCENTRALFMS_S3_SECRET }}
+        export UCENTRALFMS_S3_KEY=${{ secrets.UCENTRALFMS_S3_KEY }}
+        export CERT_LOCATION=cert.pem
+        export KEY_LOCATION=key.pem
        ./deploy.sh

    - name: Show resource state on deployment failure
--- a/.github/workflows/uc_interop.yml
+++ b/.github/workflows/uc_interop.yml
@@ -0,0 +1,290 @@
+name: 2.x interop testing
+
+env:
+  # thirdparties
+  DOCKER_SERVER: tip-tip-wlan-cloud-docker-repo.jfrog.io
+  DOCKER_USER_NAME: wlan-testing-cicd
+  DOCKER_USER_PASSWORD: ${{ secrets.DOCKER_USER_PASSWORD }}
+  # AWS credentials
+  AWS_EKS_NAME: tip-wlan-main
+  AWS_DEFAULT_OUTPUT: json
+  AWS_DEFAULT_REGION: us-east-2
+  AWS_ACCOUNT_ID: ${{ secrets.AWS_ACCOUNT_ID }}
+  AWS_ACCESS_KEY_ID: ${{ secrets.AWS_CLIENT_ID }}
+  AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_CLIENT_KEY }}
+  # Cloud SDK certs
+  CACERT: ${{ secrets.CACERT }}
+  CAKEY: ${{ secrets.CAKEY }}
+  ALLURE_CLI_VERSION: 2.14.0
+
+on:
+  workflow_dispatch:
+    inputs:
+      additional_markers:
+        default: ''
+        description: 'Pass additional markers that will be and-combined with the interop marker, e.g. "twog or fiveg" -> "interop and twog or fiveg"'
+        required: false
+  schedule:
+  - cron: '15 0 * * *'
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    # checkout needed repositories
+    - name: Checkout Testing repo
+      uses: actions/checkout@v2
+      with:
+        path: wlan-testing
+
+    - name: Checkout LANforge scripts
+      uses: actions/checkout@v2
+      with:
+        path: wlan-lanforge-scripts
+        repository: Telecominfraproject/wlan-lanforge-scripts
+
+    - name: import LANforge scripts
+      working-directory: wlan-testing
+      run: ./sync_repos.bash
+
+    # build and push docker image
+    - name: docker login
+      run: docker login ${{ env.DOCKER_SERVER }} -u ${{ env.DOCKER_USER_NAME }} -p ${{ env.DOCKER_USER_PASSWORD }}
+    - name: build docker image
+      working-directory: wlan-testing
+      run: docker build -t ${{ env.DOCKER_SERVER }}/cloud-sdk-nightly:${{ github.run_id }} -f docker/Dockerfile .
+    - name: push docker image
+      run: docker push ${{ env.DOCKER_SERVER }}/cloud-sdk-nightly:${{ github.run_id }}
+
+
+  test:
+    runs-on: ubuntu-latest
+    needs: [ build ]
+    strategy:
+      fail-fast: false
+      max-parallel: 1
+      matrix:
+        test_type: [android, ios]
+
+    outputs:
+      additional_markers: ${{ steps.marker.outputs.additional }}
+
+    steps:
+    - name: get EKS access credentials
+      run: aws eks update-kubeconfig  --name ${{ env.AWS_EKS_NAME }}
+
+    - name: install Allure CLI tool
+      run: |
+        wget https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/${{ env.ALLURE_CLI_VERSION }}/allure-commandline-${{ env.ALLURE_CLI_VERSION }}.tgz
+        tar -xzf allure-commandline-${{ env.ALLURE_CLI_VERSION }}.tgz
+        
+    - name: set job name
+      id: job
+      run: echo "::set-output name=name::2-x-interop-ci-${{ github.run_number }}-${{ matrix.test_type }}"
+
+    - name: create configuration.py secret
+      run: |
+        cat << EOF > configuration.py
+        ${{ secrets.LAB_CONFIGURATION }}
+        EOF
+        kubectl create secret generic configuration --from-file=configuration=./configuration.py
+
+    - name: calculate marker expression
+      id: marker
+      run: |
+        if [ "${{ matrix.test_type }}" = "android" ]; then
+          MARKER_EXPRESSION="interop_and"
+        else
+          MARKER_EXPRESSION="interop_ios"
+        fi
+
+        ADDITIONAL_MARKERS="${{ github.event.inputs.additional_markers || '' }}"
+        if [ ! -z "$ADDITIONAL_MARKERS" ]; then
+          MARKER_EXPRESSION="$MARKER_EXPRESSION and ${ADDITIONAL_MARKERS}"
+        fi
+
+        echo "::set-output name=additional::${ADDITIONAL_MARKERS}"
+        echo "::set-output name=expression::${MARKER_EXPRESSION}"
+        
+    - name: run interop tests
+      run: |
+        cat <<EOF | kubectl apply -f -
+        apiVersion: batch/v1
+        kind: Job
+        metadata:
+          name: "${{ steps.job.outputs.name }}"
+        spec:
+          template:
+            spec:
+              containers:
+              - name: tests
+                image: ${{ env.DOCKER_SERVER }}/cloud-sdk-nightly:${{ github.run_id }}
+                command:
+                  - /bin/bash
+                  - -x
+                  - -c
+                  - |
+                    cd tests
+                    pytest -m "${{ steps.marker.outputs.expression }}" -s -vvv --testbed=interop -o 'jobName=Github-Interop-${{ matrix.test_type }}' -o 'jobNumber=${{ github.run_number }}' --skip-testrail --alluredir=/tmp/allure-results
+                    ret=\$?
+                    # sleep some time to be able to download the Allure results
+                    sleep 60
+                    exit \$ret
+                volumeMounts:
+                - name: configuration
+                  mountPath: "/wlan-testing/tests/configuration.py"
+                  subPath: configuration
+                  readOnly: true
+              imagePullSecrets:
+              - name: tip-docker-registry-key
+              restartPolicy: Never
+              volumes:
+              - name: configuration
+                secret:
+                  secretName: configuration
+          backoffLimit: 0
+        EOF
+        # wait for pod to spawn
+        sleep 1
+
+        podname=$(kubectl get pods --no-headers -o custom-columns=":metadata.name" -l job-name="${{ steps.job.outputs.name }}" | sed "s/pod\///")
+
+        kubectl wait "pod/$podname" --for condition=ready
+
+        until [ -s test_everything.xml ]
+        do
+          sleep 10
+          echo "waiting for tests to complete..."
+          kubectl cp $podname:/wlan-testing/tests/test_everything.xml test_everything.xml >/dev/null 2>&1
+        done
+        echo "tests completed"
+        echo "downloading allure results..."
+        kubectl cp $podname:/tmp/allure-results allure-results >/dev/null 2>&1
+        echo "waiting for pod to exit"
+        kubectl logs -f $podname >/dev/null 2>&1
+        exit $(kubectl get pod $podname --output="jsonpath={.status.containerStatuses[].state.terminated.exitCode}")
+
+    - name: print logs
+      if: ${{ always() }}
+      run: |
+        podname=$(kubectl get pods --no-headers -o custom-columns=":metadata.name" -l job-name="${{ steps.job.outputs.name }}" | sed "s/pod\///")
+        kubectl logs $podname
+
+    - name: upload Allure results as artifact
+      if: ${{ always() }}
+      uses: actions/upload-artifact@v2
+      with:
+        name: allure-results-${{ matrix.test_type }}
+        path: allure-results
+
+    - name: cleanup
+      if: ${{ always() }}
+      run: |
+        kubectl delete job "${{ steps.job.outputs.name }}" --wait=true --ignore-not-found=true
+        kubectl delete secret configuration --wait=true --ignore-not-found=true
+
+  report:
+    needs: [ test ]
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+    - name: install Allure CLI tool
+      run: |
+        wget https://repo.maven.apache.org/maven2/io/qameta/allure/allure-commandline/${{ env.ALLURE_CLI_VERSION }}/allure-commandline-${{ env.ALLURE_CLI_VERSION }}.tgz
+        tar -xzf allure-commandline-${{ env.ALLURE_CLI_VERSION }}.tgz
+
+    - uses: actions/download-artifact@v2
+      with:
+        name: allure-results-android
+        path: allure-results-android
+
+    - uses: actions/download-artifact@v2
+      with:
+        name: allure-results-ios
+        path: allure-results-ios
+
+    - name: checkout testing repo
+      uses: actions/checkout@v2
+      with:
+        path: wlan-testing
+
+    - name: get reports branch
+      uses: actions/checkout@v2
+      continue-on-error: true
+      with:
+        ref: gh-pages
+        path: reports
+
+    - name: copy history into results
+      run: |
+        if [ -e "reports/interop/2.x-interop/latest" ] ; then
+          cp -r reports/interop/2.x-interop/latest/history/ allure-results-ios/history
+          cp -r reports/interop/2.x-interop/latest/history/ allure-results-android/history
+        fi
+
+    - name: add report metadata
+      run: |
+        cat << EOF >> allure-results-android/environment.properties
+        Testbed=interop
+        Tests.CommitId=$(cd wlan-testing && git rev-parse --short HEAD)
+        CiRun.Id=${{ github.run_id }}
+        CiRun.Number=${{ github.run_number }}
+        CiRun.Url=https://github.com/${{github.repository}}/actions/runs/${{github.run_id}}
+        EOF
+
+    - name: generate Allure report
+      run: allure-${{ env.ALLURE_CLI_VERSION }}/bin/allure generate allure-results-android allure-results-ios
+
+    - name: upload Allure report as artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: allure-report
+        path: allure-report
+
+    # doing this to be able to aggregate multiple reports together later on
+    - name: copy results into report
+      run: |
+        mkdir -p allure-report/results
+        cp -r allure-results-android/* allure-report/results
+        cp -r allure-results-ios/* allure-report/results
+
+    - name: copy new report
+      run: |
+        mkdir -p reports/interop/2.x-interop
+        cp -Tr allure-report reports/interop/2.x-interop/${{ github.run_number }}
+
+    - name: update latest symlink
+      working-directory: reports/interop/2.x-interop
+      run: ln -fns ${{ github.run_number }} latest
+
+    - name: generate new index.html
+      run: python wlan-testing/.github/tools/generate_directory_index.py -r reports
+
+    - name: commit reports update
+      working-directory: reports
+      run: |
+        git config --global user.name "github-actions[bot]"
+        git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+        git add .
+        git commit -m "Automated deployment: $(date -u)"
+
+    - name: push
+      if: github.ref == 'refs/heads/master' && needs.test.outputs.additional_markers == ''
+      uses: ad-m/github-push-action@v0.6.0
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        branch: gh-pages
+        directory: reports
+
+  cleanup:
+    needs: [ test ]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+    - name: cleanup Docker image
+      run: curl -u${{ env.DOCKER_USER_NAME }}:${{ env.DOCKER_USER_PASSWORD }} -X DELETE "https://tip.jfrog.io/artifactory/tip-wlan-cloud-docker-repo/cloud-sdk-nightly/${{ github.run_id }}"
--- a/.github/workflows/uc_sanity.yml
+++ b/.github/workflows/uc_sanity.yml
@@ -1,4 +1,4 @@
-name: uCentral sanity testing
+name: 2.x sanity testing
 env:
  # thirdparties
  DOCKER_SERVER: tip-tip-wlan-cloud-docker-repo.jfrog.io
--- a/.github/workflows/ucentralgw-dev-deployment.yaml
+++ b/.github/workflows/ucentralgw-dev-deployment.yaml
@@ -79,19 +79,21 @@ jobs:
    - name: Deploy uCentralGW
      working-directory: wlan-testing/helm/ucentral
      run: |
-        export NAMESPACE="${{ matrix.namespace }}"
-        export DEPLOY_METHOD="${{ matrix.deploy_method }}"
-        export CHART_VERSION="${{ matrix.chart_version }}"
-        export UCENTRALGW_VERSION="${{ matrix.ucentralgw_version }}"
-        export UCENTRALGWUI_VERSION="${{ matrix.ucentralgwui_version }}"
-        export UCENTRALSEC_VERSION="{{ matrix.ucentralsec_version }}"
-        export UCENTRALFMS_VERSION="${{ matrix.ucentralfms_version }}"
+        export NAMESPACE=${{ matrix.namespace }}
+        export DEPLOY_METHOD=${{ matrix.deploy_method }}
+        export CHART_VERSION=${{ matrix.chart_version }}
+        export UCENTRALGW_VERSION=${{ matrix.ucentralgw_version }}
+        export UCENTRALGWUI_VERSION=${{ matrix.ucentralgwui_version }}
+        export UCENTRALSEC_VERSION=${{ matrix.ucentralsec_version }}
+        export UCENTRALFMS_VERSION=${{ matrix.ucentralfms_version }}
        export VALUES_FILE_LOCATION=values.ucentral-qa.yaml
-        export RTTY_TOKEN="${{ secrets.RTTY_TOKEN }}"
-        export UCENTRALGW_AUTH_USERNAME="${{ secrets.UCENTRALGW_AUTH_USERNAME }}"
-        export UCENTRALGW_AUTH_PASSWORD="${{ secrets.UCENTRALGW_AUTH_PASSWORD }}"
-        export UCENTRALFMS_S3_SECRET="${{ secrets.UCENTRALFMS_S3_SECRET }}"
-        export UCENTRALFMS_S3_KEY="${{ secrets.UCENTRALFMS_S3_KEY }}"
+        export RTTY_TOKEN=${{ secrets.RTTY_TOKEN }}
+        export UCENTRALGW_AUTH_USERNAME=${{ secrets.UCENTRALGW_AUTH_USERNAME }}
+        export UCENTRALGW_AUTH_PASSWORD=${{ secrets.UCENTRALGW_AUTH_PASSWORD }}
+        export UCENTRALFMS_S3_SECRET=${{ secrets.UCENTRALFMS_S3_SECRET }}
+        export UCENTRALFMS_S3_KEY=${{ secrets.UCENTRALFMS_S3_KEY }}
+        export CERT_LOCATION=cert.pem
+        export KEY_LOCATION=key.pem
        ./deploy.sh

    - name: Show resource state on deployment failure
--- a/.github/workflows/ucentralgw-qa-deployment.yaml
+++ b/.github/workflows/ucentralgw-qa-deployment.yaml
@@ -17,6 +17,14 @@ env:
  DIGICERT_KEY: ${{ secrets.DIGICERT_KEY }}

  # https://stackoverflow.com/questions/59977364/github-actions-how-use-strategy-matrix-with-script
+  # Required object fiels per environment:
+  # - namespace - namespace suffix that will used added for the Kubernetes environment (i.e. if you pass 'test', kubernetes namespace will be named 'ucentral-test')
+  # - deploy_method - deployment method for the chart deployment (supported methods - 'git' (will use helm-git from assembly chart) and 'bundle' (will use chart stored in the Artifactory0
+  # - chart_version - version of chart to be deployed from assembly chart (for 'git' method git ref may be passed, for 'bundle' method version of chart may be passed)
+  # - ucentralgw_version - uCentralGW version to deploy (will be used for Docker image tag and git branch for Helm chart if git deployment is required)
+  # - ucentralsec_version - uCentralSec version to deploy (will be used for Docker image tag and git branch for Helm chart if git deployment is required)
+  # - ucentralfms_version - uCentralFMS version to deploy (will be used for Docker image tag and git branch for Helm chart if git deployment is required)
+  # - ucentralgwui_version - uCentralGW UI version to deploy (will be used for Docker image tag and git branch for Helm chart if git deployment is required)
  testbeds: '[
    {
      "namespace": "qa01",
@@ -71,18 +79,21 @@ jobs:
    - name: Deploy uCentralGW
      working-directory: wlan-testing/helm/ucentral
      run: |
-        export NAMESPACE="${{ matrix.namespace }}"
-        export DEPLOY_METHOD="${{ matrix.deploy_method }}"
-        export CHART_VERSION="${{ matrix.chart_version }}"
-        export UCENTRALGW_VERSION="${{ matrix.ucentralgw_version }}"
-        export UCENTRALGWUI_VERSION="${{ matrix.ucentralgwui_version }}"
-        export UCENTRALSEC_VERSION="{{ matrix.ucentralsec_version }}"
-        export UCENTRALFMS_VERSION="${{ matrix.ucentralfms_version }}"
-        export RTTY_TOKEN="${{ secrets.RTTY_TOKEN }}"
-        export UCENTRALGW_AUTH_USERNAME="${{ secrets.UCENTRALGW_AUTH_USERNAME }}"
-        export UCENTRALGW_AUTH_PASSWORD="${{ secrets.UCENTRALGW_AUTH_PASSWORD }}"
-        export UCENTRALFMS_S3_SECRET="${{ secrets.UCENTRALFMS_S3_SECRET }}"
-        export UCENTRALFMS_S3_KEY="${{ secrets.UCENTRALFMS_S3_KEY }}"
+        export NAMESPACE=${{ matrix.namespace }}
+        export DEPLOY_METHOD=${{ matrix.deploy_method }}
+        export CHART_VERSION=${{ matrix.chart_version }}
+        export UCENTRALGW_VERSION=${{ matrix.ucentralgw_version }}
+        export UCENTRALGWUI_VERSION=${{ matrix.ucentralgwui_version }}
+        export UCENTRALSEC_VERSION=${{ matrix.ucentralsec_version }}
+        export UCENTRALFMS_VERSION=${{ matrix.ucentralfms_version }}
+        export VALUES_FILE_LOCATION=values.ucentral-qa.yaml
+        export RTTY_TOKEN=${{ secrets.RTTY_TOKEN }}
+        export UCENTRALGW_AUTH_USERNAME=${{ secrets.UCENTRALGW_AUTH_USERNAME }}
+        export UCENTRALGW_AUTH_PASSWORD=${{ secrets.UCENTRALGW_AUTH_PASSWORD }}
+        export UCENTRALFMS_S3_SECRET=${{ secrets.UCENTRALFMS_S3_SECRET }}
+        export UCENTRALFMS_S3_KEY=${{ secrets.UCENTRALFMS_S3_KEY }}
+        export CERT_LOCATION=cert.pem
+        export KEY_LOCATION=key.pem
        ./deploy.sh

    - name: Show resource state on deployment failure
--- a/helm/ucentral/values.ucentral-qa.external-db.yaml
+++ b/helm/ucentral/values.ucentral-qa.external-db.yaml
@@ -0,0 +1,191 @@
+ucentralgw:
+  fullnameOverride: ucentralgw
+
+  services:
+    ucentralgw:
+      type: LoadBalancer
+      annotations:
+        service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"
+        service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
+        service.beta.kubernetes.io/aws-load-balancer-healthcheck-port: "16102"
+        service.beta.kubernetes.io/aws-load-balancer-backend-protocol: ssl
+        service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn:aws:acm:us-east-2:289708231103:certificate/bfa89c7a-5b64-4a8a-bcfe-ffec655b5285"
+        service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "16002,16003,17002"
+
+  configProperties:
+    # -> Public part
+    # File uploader
+    # rtty
+    rtty.enabled: "true"
+    storage.type: postgresql
+    storage.type.postgresql.host: ucentralgw-pgsql
+    storage.type.postgresql.database: ucentralgw
+
+  certs:
+    restapi-ca.pem: |
+      -----BEGIN CERTIFICATE-----
+      MIIDojCCAoqgAwIBAgIUPVYBpqNbcLYygF6Mx+qxSWwQyFowDQYJKoZIhvcNAQEL
+      BQAwaTELMAkGA1UEBhMCVVMxJDAiBgNVBAoTG1RlbGVjb20gSW5mcmEgUHJvamVj
+      dCwgSW5jLjEMMAoGA1UECxMDVElQMSYwJAYDVQQDEx1UZWxlY29tIEluZnJhIFBy
+      b2plY3QgUm9vdCBDQTAeFw0yMTA0MTMyMjQyNDRaFw0zMTA0MTMyMjM4NDZaMGkx
+      CzAJBgNVBAYTAlVTMSQwIgYDVQQKExtUZWxlY29tIEluZnJhIFByb2plY3QsIElu
+      Yy4xDDAKBgNVBAsTA1RJUDEmMCQGA1UEAxMdVGVsZWNvbSBJbmZyYSBQcm9qZWN0
+      IFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDIGCibwf5u
+      AAwZ+1H8U0e3u2V+0d2gSctucoK86XwUmfe1V2a/qlCYZd29r80IuN1IIeB0naIm
+      KnK/MzXW87clF6tFd1+HzEvmlY/W4KyIXalVCTEzirFSvBEG2oZpM0yC3AefytAO
+      aOpA00LaM3xTfTqMKIRhJBuLy0I4ANUVG6ixVebbGuc78IodleqiLoWy2Q9QHyEO
+      t/7hZndJhiVogh0PveRhho45EbsACu7ymDY+JhlIleevqwlE3iQoq0YcmYADHno6
+      Eq8vcwLpZFxihupUafkd1T3WJYQAJf9coCjBu2qIhNgrcrGD8R9fGswwNRzMRMpX
+      720+GjcDW3bJAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFAJG
+      lmB5sVP2qfL3xZ8hQOTpkQH6MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+      AAOCAQEAVjl9dm4epG9NUYnagT9sg7scVQEPfz3Lt6w1NXJXgD8mAUlK0jXmEyvM
+      dCPD4514n+8+lM7US8fh+nxc7jO//LwK17Wm9FblgjNFR7+anv0Q99T9fP19DLlF
+      PSNHL2emogy1bl1lLTAoj8nxg2wVKPDSHBGviQ5LR9fsWUIJDv9Bs5k0qWugWYSj
+      19S6qnHeskRDB8MqRLhKMG82oDVLerSnhD0P6HjySBHgTTU7/tYS/OZr1jI6MPbG
+      L+/DtiR5fDVMNdBSGU89UNTi0wHY9+RFuNlIuvZC+x/swF0V9R5mN+ywquTPtDLA
+      5IOM7ItsRmen6u3qu+JXros54e4juQ==
+      -----END CERTIFICATE-----
+
+  postgresql:
+    enabled: true
+    fullnameOverride: ucentralgw-pgsql
+
+    postgresqlDatabase: ucentralgw
+    # Based on default values of keys storage.type.postgresql.username and storage.type.postgresql.password
+    # from https://github.com/Telecominfraproject/wlan-cloud-ucentralgw/blob/master/helm/values.yaml
+    postgresqlUsername: stephb
+    postgresqlPassword: snoopy99
+
+ucentralsec:
+  fullnameOverride: ucentralsec
+
+  services:
+    ucentralsec:
+      type: LoadBalancer
+      annotations:
+        service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"
+        service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
+        service.beta.kubernetes.io/aws-load-balancer-healthcheck-port: "16101"
+        service.beta.kubernetes.io/aws-load-balancer-backend-protocol: ssl
+        service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn:aws:acm:us-east-2:289708231103:certificate/bfa89c7a-5b64-4a8a-bcfe-ffec655b5285"
+        service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "16001,17001"
+
+  certs:
+    restapi-ca.pem: |
+      -----BEGIN CERTIFICATE-----
+      MIIDojCCAoqgAwIBAgIUPVYBpqNbcLYygF6Mx+qxSWwQyFowDQYJKoZIhvcNAQEL
+      BQAwaTELMAkGA1UEBhMCVVMxJDAiBgNVBAoTG1RlbGVjb20gSW5mcmEgUHJvamVj
+      dCwgSW5jLjEMMAoGA1UECxMDVElQMSYwJAYDVQQDEx1UZWxlY29tIEluZnJhIFBy
+      b2plY3QgUm9vdCBDQTAeFw0yMTA0MTMyMjQyNDRaFw0zMTA0MTMyMjM4NDZaMGkx
+      CzAJBgNVBAYTAlVTMSQwIgYDVQQKExtUZWxlY29tIEluZnJhIFByb2plY3QsIElu
+      Yy4xDDAKBgNVBAsTA1RJUDEmMCQGA1UEAxMdVGVsZWNvbSBJbmZyYSBQcm9qZWN0
+      IFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDIGCibwf5u
+      AAwZ+1H8U0e3u2V+0d2gSctucoK86XwUmfe1V2a/qlCYZd29r80IuN1IIeB0naIm
+      KnK/MzXW87clF6tFd1+HzEvmlY/W4KyIXalVCTEzirFSvBEG2oZpM0yC3AefytAO
+      aOpA00LaM3xTfTqMKIRhJBuLy0I4ANUVG6ixVebbGuc78IodleqiLoWy2Q9QHyEO
+      t/7hZndJhiVogh0PveRhho45EbsACu7ymDY+JhlIleevqwlE3iQoq0YcmYADHno6
+      Eq8vcwLpZFxihupUafkd1T3WJYQAJf9coCjBu2qIhNgrcrGD8R9fGswwNRzMRMpX
+      720+GjcDW3bJAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFAJG
+      lmB5sVP2qfL3xZ8hQOTpkQH6MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+      AAOCAQEAVjl9dm4epG9NUYnagT9sg7scVQEPfz3Lt6w1NXJXgD8mAUlK0jXmEyvM
+      dCPD4514n+8+lM7US8fh+nxc7jO//LwK17Wm9FblgjNFR7+anv0Q99T9fP19DLlF
+      PSNHL2emogy1bl1lLTAoj8nxg2wVKPDSHBGviQ5LR9fsWUIJDv9Bs5k0qWugWYSj
+      19S6qnHeskRDB8MqRLhKMG82oDVLerSnhD0P6HjySBHgTTU7/tYS/OZr1jI6MPbG
+      L+/DtiR5fDVMNdBSGU89UNTi0wHY9+RFuNlIuvZC+x/swF0V9R5mN+ywquTPtDLA
+      5IOM7ItsRmen6u3qu+JXros54e4juQ==
+      -----END CERTIFICATE-----
+
+rttys:
+  enabled: true
+
+  services:
+    rttys:
+      type: LoadBalancer
+      annotations:
+        service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"
+        service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
+        service.beta.kubernetes.io/aws-load-balancer-healthcheck-port: "5914"
+        service.beta.kubernetes.io/aws-load-balancer-backend-protocol: ssl
+        service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn:aws:acm:us-east-2:289708231103:certificate/bfa89c7a-5b64-4a8a-bcfe-ffec655b5285"
+        service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "5912,5913"
+
+ucentralgwui:
+  services:
+    ucentralgwui:
+      type: NodePort
+
+  ingresses:
+    default:
+      enabled: true
+      annotations:
+        kubernetes.io/ingress.class: alb
+        alb.ingress.kubernetes.io/scheme: internet-facing
+        alb.ingress.kubernetes.io/group.name: wlan-cicd
+        alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:us-east-2:289708231103:certificate/bfa89c7a-5b64-4a8a-bcfe-ffec655b5285
+        alb.ingress.kubernetes.io/listen-ports: '[{"HTTP": 80}, {"HTTPS": 443}]'
+        alb.ingress.kubernetes.io/actions.ssl-redirect: '{"Type": "redirect", "RedirectConfig": { "Protocol": "HTTPS", "Port": "443", "StatusCode": "HTTP_302"}}'
+      paths:
+      - path: /*
+        serviceName: ucentralgwui
+        servicePort: http
+
+  public_env_variables:
+    ALLOW_UCENTRALSEC_CHANGE: false
+
+ucentralfms:
+  fullnameOverride: ucentralfms
+
+  services:
+    ucentralfms:
+      type: LoadBalancer
+      annotations:
+        service.beta.kubernetes.io/aws-load-balancer-type: "nlb-ip"
+        service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
+        service.beta.kubernetes.io/aws-load-balancer-healthcheck-port: "16104"
+        service.beta.kubernetes.io/aws-load-balancer-backend-protocol: ssl
+        service.beta.kubernetes.io/aws-load-balancer-ssl-cert: "arn:aws:acm:us-east-2:289708231103:certificate/bfa89c7a-5b64-4a8a-bcfe-ffec655b5285"
+        service.beta.kubernetes.io/aws-load-balancer-ssl-ports: "16004,17004"
+
+  certs:
+    restapi-ca.pem: |
+      -----BEGIN CERTIFICATE-----
+      MIIDojCCAoqgAwIBAgIUPVYBpqNbcLYygF6Mx+qxSWwQyFowDQYJKoZIhvcNAQEL
+      BQAwaTELMAkGA1UEBhMCVVMxJDAiBgNVBAoTG1RlbGVjb20gSW5mcmEgUHJvamVj
+      dCwgSW5jLjEMMAoGA1UECxMDVElQMSYwJAYDVQQDEx1UZWxlY29tIEluZnJhIFBy
+      b2plY3QgUm9vdCBDQTAeFw0yMTA0MTMyMjQyNDRaFw0zMTA0MTMyMjM4NDZaMGkx
+      CzAJBgNVBAYTAlVTMSQwIgYDVQQKExtUZWxlY29tIEluZnJhIFByb2plY3QsIElu
+      Yy4xDDAKBgNVBAsTA1RJUDEmMCQGA1UEAxMdVGVsZWNvbSBJbmZyYSBQcm9qZWN0
+      IFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDIGCibwf5u
+      AAwZ+1H8U0e3u2V+0d2gSctucoK86XwUmfe1V2a/qlCYZd29r80IuN1IIeB0naIm
+      KnK/MzXW87clF6tFd1+HzEvmlY/W4KyIXalVCTEzirFSvBEG2oZpM0yC3AefytAO
+      aOpA00LaM3xTfTqMKIRhJBuLy0I4ANUVG6ixVebbGuc78IodleqiLoWy2Q9QHyEO
+      t/7hZndJhiVogh0PveRhho45EbsACu7ymDY+JhlIleevqwlE3iQoq0YcmYADHno6
+      Eq8vcwLpZFxihupUafkd1T3WJYQAJf9coCjBu2qIhNgrcrGD8R9fGswwNRzMRMpX
+      720+GjcDW3bJAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFAJG
+      lmB5sVP2qfL3xZ8hQOTpkQH6MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsF
+      AAOCAQEAVjl9dm4epG9NUYnagT9sg7scVQEPfz3Lt6w1NXJXgD8mAUlK0jXmEyvM
+      dCPD4514n+8+lM7US8fh+nxc7jO//LwK17Wm9FblgjNFR7+anv0Q99T9fP19DLlF
+      PSNHL2emogy1bl1lLTAoj8nxg2wVKPDSHBGviQ5LR9fsWUIJDv9Bs5k0qWugWYSj
+      19S6qnHeskRDB8MqRLhKMG82oDVLerSnhD0P6HjySBHgTTU7/tYS/OZr1jI6MPbG
+      L+/DtiR5fDVMNdBSGU89UNTi0wHY9+RFuNlIuvZC+x/swF0V9R5mN+ywquTPtDLA
+      5IOM7ItsRmen6u3qu+JXros54e4juQ==
+      -----END CERTIFICATE-----
+
+kafka:
+  heapOpts: -Xmx512m -Xms512m
+  resources:
+    requests:
+      cpu: 100m
+      memory: 512Mi
+    limits:
+      cpu: 200m
+      memory: 700Mi
+  zookeeper:
+    heapSize: 256
+    resources:
+      requests:
+        cpu: 100m
+        memory: 256Mi
+      limits:
+        cpu: 200m
+        memory: 384Mi
--- a/libs/lanforge/lf_tests.py
+++ b/libs/lanforge/lf_tests.py
@@ -214,7 +214,7 @@ class RunTest:
        return self.eap_connect.passes()

    def wifi_capacity(self, mode="BRIDGE", vlan_id=100, batch_size="1,5,10,20,40,64,128",
-                      instance_name="wct_instance", download_rate="1Gbps",
+                      instance_name="wct_instance", download_rate="1Gbps", influx_tags=[],
                      upload_rate="1Gbps", protocol="TCP-IPv4", duration="60000"):
        instance_name = ''.join(random.choices(string.ascii_uppercase + string.digits, k=S))
        if mode == "BRIDGE":
@@ -254,10 +254,12 @@ class RunTest:

        wificapacity_obj.setup()
        wificapacity_obj.run()
+        for tag in influx_tags:
+            self.influx_params["influx_tag"].append(tag)
        report_name = wificapacity_obj.report_name[0]['LAST']["response"].split(":::")[1].split("/")[-1]
-        # influx = CSVtoInflux(influxdb=self.influxdb, _influx_tag=self.influx_params["influx_tag"],
-        #                      target_csv=self.local_report_path + report_name + "/kpi.csv")
-        # influx.post_to_influx()
+        influx = CSVtoInflux(influxdb=self.influxdb, _influx_tag=self.influx_params["influx_tag"],
+                             target_csv=self.local_report_path + report_name + "/kpi.csv")
+        influx.post_to_influx()
        return wificapacity_obj

    def Client_Connect(self, ssid="[BLANK]", passkey="[BLANK]", security="wpa2", mode="BRIDGE", band="twog",
--- a/libs/lanforge/lf_tools.py
+++ b/libs/lanforge/lf_tools.py
@@ -69,7 +69,6 @@ class ChamberView:
            ["profile_link " + self.uplink_resources + " uplink-nat 1 'DUT: upstream LAN " + self.upstream_subnet
             + "' NA " + self.uplink_port.split(".")[2] + "," + self.upstream_port.split(".")[2] + " -1 NA"]
        ]
-        self.reset_dut()
        self.Chamber_View()

    def reset_dut(self):
@@ -109,35 +108,74 @@ class ChamberView:
        print(idx)
        if band == "2G":
            if num_stations != "max":
-                num_stations = int(num_stations / len(self.twog_radios))
-            for radio in self.twog_radios:
-                max_stations = 64
-                if num_stations == "max":
-                    num_stations = max_stations
-                station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
-                                str(int(idx) + 1) + "'" + " NA " + radio]
-                self.raw_line.append(station_data)
+                if num_stations > 64:
+                    num_stations = int(num_stations / len(self.twog_radios))
+                    for radio in self.twog_radios:
+                        station_data = ["profile_link " + radio.split(".")[0] + "." + radio.split(".")[1] +
+                                        " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                        str(int(idx) + 1) + "'" + " NA " + radio.split(".")[2]]
+                        self.raw_line.append(station_data)
+                else:
+                    num_stations = num_stations
+                    station_data = ["profile_link " + self.fiveg_radios[0].split(".")[0] + "." +
+                                    self.fiveg_radios[0].split(".")[1] +
+                                    " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + self.twog_radios[0].split(".")[2]]
+                    self.raw_line.append(station_data)
+            if num_stations == "max":
+                for radio in self.twog_radios:
+                    num_stations = 64
+                    station_data = ["profile_link " + radio.split(".")[0] + "." + radio.split(".")[1] +
+                                    " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + radio.split(".")[2]]
+                    self.raw_line.append(station_data)

        if band == "5G":
            if num_stations != "max":
-                num_stations = int(num_stations / len(self.fiveg_radios))
-            for radio in self.fiveg_radios:
-                max_stations = 64
-                if num_stations == "max":
-                    num_stations = max_stations
-                station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
-                                str(int(idx) + 1) + "'" + " NA " + radio]
-                self.raw_line.append(station_data)
+                if num_stations > 64:
+                    num_stations = int(num_stations / len(self.fiveg_radios))
+                    for radio in self.fiveg_radios:
+                        station_data = ["profile_link " + radio.split(".")[0] + "." + radio.split(".")[1] +
+                                        " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                        str(int(idx) + 1) + "'" + " NA " + radio.split(".")[2]]
+                        print(station_data)
+                        self.raw_line.append(station_data)
+                else:
+                    num_stations = num_stations
+                    station_data = ["profile_link " + self.fiveg_radios[0].split(".")[0] + "." +
+                                    self.fiveg_radios[0].split(".")[1] +
+                                    " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + self.fiveg_radios[0].split(".")[2]]
+                    print(station_data)
+                    self.raw_line.append(station_data)
+            if num_stations == "max":
+                for radio in self.fiveg_radios:
+                    num_stations = 64
+                    station_data = ["profile_link " + radio.split(".")[0] + "." + radio.split(".")[1] +
+                                    " STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + radio.split(".")[2]]
+                    print(station_data)
+                    self.raw_line.append(station_data)
+
        if band == "ax":
            if num_stations != "max":
-                num_stations = int(num_stations / len(self.fiveg_radios))
-            for radio in self.ax_radios:
-                max_stations = 1
-                if num_stations == "max":
-                    num_stations = max_stations
-                station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
-                                str(int(idx) + 1) + "'" + " NA " + radio]
-                self.raw_line.append(station_data)
+                if num_stations > 1:
+                    num_stations = int(num_stations / len(self.ax_radios))
+                    for radio in self.ax_radios:
+                        station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                        str(int(idx) + 1) + "'" + " NA " + radio]
+                        self.raw_line.append(station_data)
+                else:
+                    num_stations = num_stations
+                    station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + self.ax_radios[0]]
+                    self.raw_line.append(station_data)
+            if num_stations == "max":
+                for radio in self.ax_radios:
+                    num_stations = 1
+                    station_data = ["profile_link 1.1 STA-AUTO " + str(num_stations) + " 'DUT: " + dut + " Radio-" +
+                                    str(int(idx) + 1) + "'" + " NA " + radio]
+                    self.raw_line.append(station_data)

    def Create_Dut(self):
        self.CreateDut.setup()
--- a/libs/perfecto_libs/android_lib.py
+++ b/libs/perfecto_libs/android_lib.py
@@ -805,3 +805,210 @@ def verify_APconnMobileDevice_Android(request, profileNameSSID, setup_perfectoMo
        assert False

    closeApp(connData["appPackage-android"], setup_perfectoMobile)
+
+    # Cache_clear Function
+def cache_clear_android(request, setup_perfectoMobile, connData):
+    print("\n-------------------------------------")
+    print("Select Cache Clear")
+    print("-------------------------------------")
+    report = setup_perfectoMobile[1]
+    driver = setup_perfectoMobile[0]
+
+    report.step_start("Switching Driver Context")
+    print("Switching Context to Native")
+    contexts = driver.contexts
+    driver.switch_to.context(contexts[0])
+
+    # Open Settings Application
+    openApp(connData["appPackage-android"], setup_perfectoMobile)
+
+    deviceModelName = getDeviceModelName(setup_perfectoMobile)
+    print("Selected Device Model: " + deviceModelName)
+
+    if deviceModelName != ("Pixel 4" and "Galaxy S9"):
+        try:
+            print("Clicking Search button")
+            report.step_start("Click Search")
+            conn_ele = driver.find_element_by_xpath("//*[@content-desc='Search']")
+            conn_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Search")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Entering Chrome in Search")
+            report.step_start("Entering text Chrome")
+            search_ele = driver.find_element_by_xpath("//*[@resource-id='com.android.settings.intelligence:id/search_src_text']")
+            search_ele.send_keys("chrome")
+        except Exception as e:
+            print("Exception: Entering chrome failed")
+            print(e)
+
+        try:
+            driver.implicitly_wait(40)
+            print("Clicking Chrome App Info")
+            report.step_start("Click Chrome App Info")
+            chrome_ele = driver.find_element_by_xpath("//*[@text='Chrome']")
+            chrome_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Chrome")
+
+        # Scroll Down
+        scrollDown(setup_perfectoMobile)
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Storage")
+            report.step_start("Click Storage")
+            store_ele = driver.find_element_by_xpath("//*[@text='Storage']")
+            store_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Storage")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Clear Cache")
+            report.step_start("Click Clear Cache")
+            clear_ele = driver.find_element_by_xpath("//*[@resource-id='com.android.settings:id/button2']")
+            clear_ele.click()
+            print("Cleared Cache")
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Clearcache")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Checking if cache cleared or not with 0B")
+            report.step_start("Checking if cache cleared or not with 0B")
+            check_ele = driver.find_element_by_xpath("//*[@text='0 B']")
+            if check_ele is not None:
+                return True
+            else:
+                return False
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Checking cache clear")
+
+    elif deviceModelName == ("Pixel 4"):
+        # Pixel cache clear code
+        try:
+            print("Clicking Search button")
+            report.step_start("Click Search")
+            conn_ele = driver.find_element_by_xpath("//*[@class='android.widget.ImageButton']")
+            conn_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Search")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Entering Chrome in Search")
+            report.step_start("Entering text Chrome")
+            search_ele = driver.find_element_by_xpath("//*[@resource-id='android:id/search_src_text']")
+            search_ele.send_keys("chrome")
+        except Exception as e:
+            print("Exception: Entering chrome failed")
+            print(e)
+
+        try:
+            driver.implicitly_wait(35)
+            print("Clicking Chrome App Info")
+            report.step_start("Click Chrome App Info")
+            chrom_ele = driver.find_element_by_xpath("//*[@text='Chrome']")
+            chrom_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Chrome")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Storage & cache")
+            report.step_start("Click Storage & cache")
+            store_ele = driver.find_element_by_xpath("//*[@text='Storage & cache']")
+            store_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Storage & cache")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Clear Cache")
+            report.step_start("Click Clear Cache")
+            clear_ele = driver.find_element_by_xpath("//*[@resource-id='com.android.settings:id/button2']")
+            clear_ele.click()
+            print("Cleared cache")
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Clearcache")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Checking if cache cleared or not with 0B")
+            report.step_start("Checking if cache cleared or not with 0B")
+            store_ele = driver.find_element_by_xpath("//*[@text='0 B']")
+            if store_ele is not None:
+                return True
+            else:
+                return False
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Checking cache clear")
+
+    else:
+        try:
+            print("Clicking Search button")
+            report.step_start("Click Search")
+            conn_ele = driver.find_element_by_xpath("//*[@content-desc='Search settings']")
+            conn_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Search")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Entering Chrome in Search")
+            report.step_start("Entering text Chrome")
+            search_ele = driver.find_element_by_xpath(
+                "//*[@resource-id='com.android.settings.intelligence:id/search_src_text']")
+            search_ele.send_keys("chrome")
+        except Exception as e:
+            print("Exception: Entering chrome failed")
+            print(e)
+
+        try:
+            driver.implicitly_wait(40)
+            print("Clicking Chrome App Info")
+            report.step_start("Click Chrome App Info")
+            chrome_ele = driver.find_element_by_xpath("//*[@text='Chrome']")
+            chrome_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Chrome")
+
+        # Scroll Down
+        scrollDown(setup_perfectoMobile)
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Storage")
+            report.step_start("Click Storage")
+            store_ele = driver.find_element_by_xpath("//*[@text='Storage']")
+            store_ele.click()
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Storage")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Clicking Clear Cache")
+            report.step_start("Click Clear Cache")
+            clear_ele = driver.find_element_by_xpath("//*[@resource-id='com.android.settings:id/button2']")
+            clear_ele.click()
+            print("Cleared Cache")
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Click Clearcache")
+
+        try:
+            driver.implicitly_wait(30)
+            print("Checking if cache cleared or not with 0B")
+            report.step_start("Checking if cache cleared or not with 0B")
+            check_ele = driver.find_element_by_xpath("//*[@text='0 B']")
+            if check_ele is not None:
+                return True
+            else:
+                return False
+        except NoSuchElementException:
+            print("Exception: Verify Xpath - Update/check Xpath for Checking cache clear")
+
+
+    closeApp(connData["appPackage-android"], setup_perfectoMobile)
--- a/tests/configuration.py
+++ b/tests/configuration.py
@@ -216,9 +216,9 @@ CONFIGURATION = {
                "ip": "10.28.3.28",
                "port": 8080,
                "ssh_port": 22,
-                "2.4G-Radio": ["1.1.wiphy2"],
-                "5G-Radio": ["1.1.wiphy3"],
-                "AX-Radio": ["1.1.wiphy0", "1.1.wiphy1", "1.1.wiphy2", "1.1.wiphy3"],
+                "2.4G-Radio": ["1.1.wiphy0", "1.1.wiphy2"],
+                "5G-Radio": ["1.1.wiphy1", "1.1.wiphy3"],
+                "AX-Radio": ["1.1.wiphy4", "1.1.wiphy5", "1.1.wiphy6", "1.1.wiphy7"],
                "upstream": "1.1.eth2",
                "upstream_subnet": "10.28.2.1/24",
                "uplink": "1.1.eth1",
--- a/tests/e2e/basic/conftest.py
+++ b/tests/e2e/basic/conftest.py
@@ -81,6 +81,7 @@ def setup_profiles(request, setup_controller, testbed, get_equipment_id, fixture
                                             get_markers, create_lanforge_chamberview_dut, lf_tools,
                                             get_security_flags, get_configuration, radius_info, get_apnos,
                                             radius_accounting_info)
+
    yield return_var


--- a/tests/e2e/basic/performance_tests/dual_band_performance_test/wpa2_personal/test_nat_mode.py
+++ b/tests/e2e/basic/performance_tests/dual_band_performance_test/wpa2_personal/test_nat_mode.py
@@ -10,8 +10,7 @@ import allure
 import pytest

 pytestmark = [pytest.mark.performance, pytest.mark.dual_band_test, pytest.mark.nat,
-              pytest.mark.single_station_dual_band_throughput, pytest.mark.usefixtures("setup_test_run")]
-
+              pytest.mark.single_station_dual_band_throughput]
 setup_params_general = {
    "mode": "NAT",
    "ssid_modes": {
--- a/tests/e2e/basic/performance_tests/wifi_capacity_test/test_bridge_mode.py
+++ b/tests/e2e/basic/performance_tests/wifi_capacity_test/test_bridge_mode.py
@@ -50,6 +50,7 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
        """ Wifi Capacity Test BRIDGE mode
            pytest -m "wifi_capacity_test and BRIDGE and wpa2_personal and twog"
        """
+        lf_tools.reset_scenario()
        profile_data = setup_params_general_dual_band["ssid_modes"]["wpa2_personal"][0]
        ssid_name = profile_data["ssid_name"]
        mode = "BRIDGE"
@@ -60,10 +61,12 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        lf_tools.add_stations(band="2G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.add_stations(band="5G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
-        lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
+        # lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.Chamber_View()
+        influx_tags = ["tcp", "download", "2.4G-5G Combined"]
        wct_obj = lf_test.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_dl", mode=mode, vlan_id=vlan,
-                                        download_rate="1Gbps",
+                                        download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256",
+                                        influx_tags=influx_tags,
                                        upload_rate="0", protocol="TCP-IPv4", duration="60000")

        report_name = wct_obj.report_name[0]['LAST']["response"].split(":::")[1].split("/")[-1]
@@ -79,6 +82,7 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
        """ Wifi Capacity Test BRIDGE mode
            pytest -m "wifi_capacity_test and BRIDGE and wpa2_personal and twog"
        """
+        lf_tools.reset_scenario()
        profile_data = setup_params_general_dual_band["ssid_modes"]["wpa2_personal"][0]
        ssid_name = profile_data["ssid_name"]
        mode = "BRIDGE"
@@ -89,10 +93,12 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        lf_tools.add_stations(band="2G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.add_stations(band="5G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
-        lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
+        # lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.Chamber_View()
+        influx_tags = ["udp", "download", "2.4G-5G Combined"]
        wct_obj = lf_test.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_dl", mode=mode, vlan_id=vlan,
-                                        download_rate="1Gbps",
+                                        download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256",
+                                        influx_tags=influx_tags,
                                        upload_rate="0", protocol="UDP-IPv4", duration="60000")

        report_name = wct_obj.report_name[0]['LAST']["response"].split(":::")[1].split("/")[-1]
@@ -108,6 +114,7 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
        """ Wifi Capacity Test BRIDGE mode
            pytest -m "wifi_capacity_test and BRIDGE and wpa2_personal and twog"
        """
+        lf_tools.reset_scenario()
        profile_data = setup_params_general_dual_band["ssid_modes"]["wpa2_personal"][0]
        ssid_name = profile_data["ssid_name"]
        mode = "BRIDGE"
@@ -117,10 +124,12 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        lf_tools.add_stations(band="2G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.add_stations(band="5G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
-        lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
+        # lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.Chamber_View()
+        influx_tags = ["tcp", "bidirectional", "2.4G-5G Combined"]
        wct_obj = lf_test.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_tcp_bi", mode=mode, vlan_id=vlan,
-                                        download_rate="1Gbps",
+                                        download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256",
+                                        influx_tags=influx_tags,
                                        upload_rate="1Gbps", protocol="TCP-IPv4", duration="60000")

        report_name = wct_obj.report_name[0]['LAST']["response"].split(":::")[1].split("/")[-1]
@@ -136,6 +145,7 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
        """ Wifi Capacity Test BRIDGE mode
            pytest -m "wifi_capacity_test and BRIDGE and wpa2_personal and twog"
        """
+        lf_tools.reset_scenario()
        profile_data = setup_params_general_dual_band["ssid_modes"]["wpa2_personal"][0]
        ssid_name = profile_data["ssid_name"]
        mode = "BRIDGE"
@@ -145,10 +155,12 @@ class TestWifiCapacityBRIDGEModeDualBand(object):
            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        lf_tools.add_stations(band="2G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.add_stations(band="5G", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
-        lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
+        # lf_tools.add_stations(band="ax", num_stations="max", dut=lf_tools.dut_name, ssid_name=ssid_name)
        lf_tools.Chamber_View()
+        influx_tags = ["udp", "bidirectional", "2.4G-5G Combined"]
        wct_obj = lf_test.wifi_capacity(instance_name="test_client_wpa2_BRIDGE_udp_bi", mode=mode, vlan_id=vlan,
-                                        download_rate="1Gbps",
+                                        download_rate="1Gbps", batch_size="1,5,10,20,40,64,128,256",
+                                        influx_tags=influx_tags,
                                        upload_rate="1Gbps", protocol="UDP-IPv4", duration="60000")

        report_name = wct_obj.report_name[0]['LAST']["response"].split(":::")[1].split("/")[-1]
--- a/tests/e2e/basic/performance_tests/wifi_capacity_test/test_nat_mode.py
+++ b/tests/e2e/basic/performance_tests/wifi_capacity_test/test_nat_mode.py
@@ -36,7 +36,6 @@ setup_params_general_dual_band = {
@pytest.mark.twog
@pytest.mark.fiveg
@pytest.mark.dual_band
-@pytest.mark.wifi_capacity_test
 class TestWifiCapacityNATModeDualBand(object):
    """ Wifi Capacity Test NAT mode
           pytest -m "wifi_capacity_test and NAT"
--- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_enterprise_ttls.py
+++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_enterprise_ttls.py
@@ -8,7 +8,7 @@ import allure
 import pytest

 pytestmark = [pytest.mark.client_connectivity, pytest.mark.bridge, pytest.mark.enterprise, pytest.mark.ttls,
-              pytest.mark.ucentral, pytest.mark.sanity]#, pytest.mark.usefixtures("setup_test_run")]
+              pytest.mark.ucentral, pytest.mark.sanity]  # , pytest.mark.usefixtures("setup_test_run")]

 setup_params_enterprise = {
    "mode": "BRIDGE",
@@ -28,6 +28,8 @@ setup_params_enterprise = {
 }


+@allure.suite(suite_name="sanity")
+@allure.sub_suite(sub_suite_name="Bridge Mode EAP Client Connectivity : Suite-A")
@pytest.mark.suiteA
@pytest.mark.parametrize(
    'setup_profiles',
@@ -220,6 +222,8 @@ setup_params_enterprise_two = {
 }


+@allure.suite(suite_name="sanity")
+@allure.sub_suite(sub_suite_name="Bridge Mode EAP Client Connectivity : Suite-B")
@pytest.mark.suiteB
@pytest.mark.parametrize(
    'setup_profiles',
--- a/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_general_security_modes.py
+++ b/tests/e2e/basic/validation_of_operating_modes/bridge_mode/client_connectivity/test_general_security_modes.py
@@ -29,6 +29,8 @@ setup_params_general = {
 }


+@allure.suite(suite_name="sanity")
+@allure.sub_suite(sub_suite_name="Bridge Mode Client Connectivity : Suite-A")
@pytest.mark.suiteA
@pytest.mark.sudo
@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
@@ -46,7 +48,7 @@ class TestBridgeModeConnectivitySuiteA(object):

    @pytest.mark.open
    @pytest.mark.twog
-    @allure.story('open 2.4 GHZ Band')
+    @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-2809", name="JIRA LINK")
    def test_open_ssid_2g(self, get_vif_state, setup_profiles, get_lanforge_data, lf_test, update_report,
                          station_names_twog,
                          test_cases):
@@ -72,7 +74,7 @@ class TestBridgeModeConnectivitySuiteA(object):

    @pytest.mark.open
    @pytest.mark.fiveg
-    @allure.story('open 5 GHZ Band')
+    @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-2801", name="JIRA LINK")
    def test_open_ssid_5g(self, get_vif_state, get_lanforge_data, lf_test, test_cases, station_names_fiveg,
                          update_report):
        """Client Connectivity open ssid 5G
@@ -99,6 +101,7 @@ class TestBridgeModeConnectivitySuiteA(object):
    @pytest.mark.wpa
    @pytest.mark.twog
    @allure.story('wpa 2.4 GHZ Band')
+    @allure.testcase(url="https://telecominfraproject.atlassian.net/browse/WIFI-2801", name="JIRA LINK")
    def test_wpa_ssid_2g(self, get_vif_state, get_lanforge_data, update_report,
                         lf_test, test_cases, station_names_twog):
        """Client Connectivity wpa ssid 2.4G
@@ -222,6 +225,8 @@ setup_params_general_two = {
 }


+@allure.suite(suite_name="sanity")
+@allure.sub_suite(sub_suite_name="Bridge Mode Client Connectivity : Suite-B")
@pytest.mark.suiteB
@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
@pytest.mark.parametrize(
@@ -260,8 +265,6 @@ class TestBridgeModeConnectivitySuiteTwo(object):
                                                     passkey=security_key, mode=mode, band=band,
                                                     station_name=station_names_twog, vlan_id=vlan)

-        if not result:
-            pytest.xfail("")
        assert result

    @pytest.mark.wpa3_personal
--- a/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_general_security_modes.py
+++ b/tests/e2e/basic/validation_of_operating_modes/nat_mode/client_connectivity/test_general_security_modes.py
@@ -121,8 +121,6 @@ class TestNATModeConnectivitySuiteA(object):
        passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security,
                                                     passkey=security_key, mode=mode, band=band,
                                                     station_name=station_names_twog, vlan_id=vlan)
-        if not result:
-            pytest.xfail("ssid issue")
        assert result

    @pytest.mark.sanity_light
@@ -148,8 +146,7 @@ class TestNATModeConnectivitySuiteA(object):
        passes, result = lf_test.Client_Connectivity(ssid=ssid_name, security=security,
                                                     passkey=security_key, mode=mode, band=band,
                                                     station_name=station_names_fiveg, vlan_id=vlan)
-        if not result:
-            pytest.xfail("ssid issue")
+        
        assert result

    @pytest.mark.sanity_light
--- a/tests/e2e/interOp/android/AirplaneMode/test_ToggleAirplaneMode.py
+++ b/tests/e2e/interOp/android/AirplaneMode/test_ToggleAirplaneMode.py
@@ -13,15 +13,13 @@ from selenium.common.exceptions import NoSuchElementException
 import sys
 import allure

-pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.android, pytest.mark.interop_and, pytest.mark.ToggleAirplaneMode]
-
 if 'perfecto_libs' not in sys.path:
    sys.path.append(f'../libs/perfecto_libs')

+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.android, pytest.mark.interop_and, pytest.mark.ToggleAirplaneMode]

 from android_lib import closeApp, set_APconnMobileDevice_android, Toggle_AirplaneMode_android, ForgetWifiConnection, openApp

-
 setup_params_general = {
    "mode": "NAT",
    "ssid_modes": {
@@ -31,7 +29,8 @@ setup_params_general = {
                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}],
        "wpa2_personal": [
            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
-            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}]},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}]
+    },
    "rf": {},
    "radius": False
 }
@@ -47,65 +46,11 @@ setup_params_general = {
@pytest.mark.usefixtures("setup_profiles")
 class TestToggleAirplaneModeAndroid(object):

-    @pytest.mark.open
-    @pytest.mark.fiveg
-    def test_ToogleAirplaneMode_5g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-
-        profile_data = setup_params_general["ssid_modes"]["open"][1]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = "[BLANK]"
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
-
-        #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
-
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-    @pytest.mark.open
-    @pytest.mark.twog
-    def test_ToogleAirplaneMode_2g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-
-        profile_data = setup_params_general["ssid_modes"]["open"][0]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = "[BLANK]"
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
-
-         #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
-
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
    @pytest.mark.fiveg
    @pytest.mark.wpa2_personal
    def test_ToogleAirplaneMode_5g_WPA2_Personal(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-        
-        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]  
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
        ssidName = profile_data["ssid_name"]
        ssidPassword = profile_data["security_key"]
        print ("SSID_NAME: " + ssidName)
@@ -131,8 +76,8 @@ class TestToggleAirplaneModeAndroid(object):
    @pytest.mark.twog
    @pytest.mark.wpa2_personal
    def test_ToogleAirplaneMode_2g_WPA2_Personal(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-        
-        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] 
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
        ssidName = profile_data["ssid_name"]
        ssidPassword = profile_data["security_key"]
        print ("SSID_NAME: " + ssidName)
@@ -158,7 +103,7 @@ class TestToggleAirplaneModeAndroid(object):
    @pytest.mark.fiveg
    @pytest.mark.wpa
    def test_ToogleAirplaneMode_5g_WPA(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-        
+
        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
        ssidName = profile_data["ssid_name"]
        ssidPassword = profile_data["security_key"]
@@ -185,8 +130,8 @@ class TestToggleAirplaneModeAndroid(object):
    @pytest.mark.twog
    @pytest.mark.wpa
    def test_ToogleAirplaneMode_2g_WPA(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
-        
-        profile_data = setup_params_general["ssid_modes"]["wpa"][0] 
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
        ssidName = profile_data["ssid_name"]
        ssidPassword = profile_data["security_key"]
        print ("SSID_NAME: " + ssidName)
@@ -207,4 +152,57 @@ class TestToggleAirplaneModeAndroid(object):
        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)

        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+    @pytest.mark.fiveg
+    @pytest.mark.open
+    def test_ToogleAirplaneMode_5g_Open(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.open
+    def test_ToogleAirplaneMode_2g_Open(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
--- a/tests/e2e/interOp/android/AirplaneMode/test_ToggleAirplaneMode_BridgeMode.py
+++ b/tests/e2e/interOp/android/AirplaneMode/test_ToggleAirplaneMode_BridgeMode.py
@@ -0,0 +1,209 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+
+import sys
+import allure
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.android, pytest.mark.interop_and, pytest.mark.ToggleAirplaneMode]
+
+from android_lib import closeApp, set_APconnMobileDevice_android, Toggle_AirplaneMode_android, ForgetWifiConnection, openApp
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+                 "security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+
+@pytest.mark.usefixtures("setup_profiles")
+class TestToggleAirplaneModeAndroidBridgeMode(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_ToogleAirplaneMode_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_ToogleAirplaneMode_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_ToogleAirplaneMode_5g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_ToogleAirplaneMode_2g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+    @pytest.mark.fiveg
+    @pytest.mark.open
+    def test_ToogleAirplaneMode_5g_Open_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.open
+    def test_ToogleAirplaneMode_2g_Open_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
--- a/tests/e2e/interOp/android/OpenRoamingPassPoint/test_OpenRoaming_BridgeMode.py
+++ b/tests/e2e/interOp/android/OpenRoamingPassPoint/test_OpenRoaming_BridgeMode.py
@@ -51,7 +51,7 @@ setup_params_eap = {
 )
@pytest.mark.usefixtures("setup_profiles")
 class TestOpenRoamingBridgeMode(object):
-  
+
    @pytest.mark.wpa2_eap
    @pytest.mark.twog
    @pytest.mark.parametrize(
@@ -66,11 +66,14 @@ class TestOpenRoamingBridgeMode(object):
            EAP Passpoint BRIDGE Mode
            pytest -m "interop_iOS and eap_passpoint and bridge and wpa2_eap and twog"
        """
+
        result = push_ap_profile['ssid_wpa2_eap_passpoint_2g']['vif_config']
+        print(result)
        if result:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_2g']['vif_state']
        if result:
@@ -143,6 +146,7 @@ class TestOpenRoamingBridgeMode(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_5g']['vif_state']
        if result:
@@ -213,6 +217,7 @@ class TestOpenRoamingBridgeMode(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_2g']['vif_state']
        if result:
@@ -284,6 +289,7 @@ class TestOpenRoamingBridgeMode(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_5g']['vif_state']
        if result:
--- a/tests/e2e/interOp/android/PassPointConnection/test_PassPointConnection.py
+++ b/tests/e2e/interOp/android/PassPointConnection/test_PassPointConnection.py
@@ -44,62 +44,6 @@ setup_params_general = {

@pytest.mark.usefixtures("setup_profiles")
 class TestPassPointConnection(object):
-    @pytest.mark.open
-    @pytest.mark.fiveg
-    def test_ToogleAirplaneMode_5g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
-                                        setup_perfectoMobile_android):
-
-        profile_data = setup_params_general["ssid_modes"]["open"][1]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = "[BLANK]"
-        print("SSID_NAME: " + ssidName)
-        print("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
-
-        # Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        # Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
-
-        # ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-    @pytest.mark.open
-    @pytest.mark.twog
-    def test_ToogleAirplaneMode_2g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
-                                        setup_perfectoMobile_android):
-
-        profile_data = setup_params_general["ssid_modes"]["open"][0]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = "[BLANK]"
-        print("SSID_NAME: " + ssidName)
-        print("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
-
-        # Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        # Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
-
-        # ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-

    @pytest.mark.fiveg
    @pytest.mark.wpa2_personal
@@ -219,4 +163,61 @@ class TestPassPointConnection(object):
        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)

        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.fiveg
+    def test_PassPointConnection_5g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.twog
+    def test_PassPointConnection_2g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
--- a/tests/e2e/interOp/android/PassPointConnection/test_PassPointConnection_BridgeMode.py
+++ b/tests/e2e/interOp/android/PassPointConnection/test_PassPointConnection_BridgeMode.py
@@ -0,0 +1,223 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+
+import sys
+import allure
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.android, pytest.mark.interop_and, pytest.mark.PassPointConnection]
+
+from android_lib import closeApp, set_APconnMobileDevice_android, verifyUploadDownloadSpeed_android, Toggle_WifiMode_android, Toggle_AirplaneMode_android, ForgetWifiConnection, openApp
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+
+@pytest.mark.usefixtures("setup_profiles")
+class TestPassPointConnectionBridgeMode(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_PassPointConnection_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Verify Upload download Speed from device Selection
+        assert verifyUploadDownloadSpeed_android(request, setup_perfectoMobile_android, connData)
+
+        #Toggle Wifi Mode
+        Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_PassPointConnection_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Verify Upload download Speed from device Selection
+        assert verifyUploadDownloadSpeed_android(request, setup_perfectoMobile_android, connData)
+
+        #Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_PassPointConnection_5g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Verify Upload download Speed from device Selection
+        assert verifyUploadDownloadSpeed_android(request, setup_perfectoMobile_android, connData)
+
+        #Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_PassPointConnection_2g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+         #Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        #Verify Upload download Speed from device Selection
+        assert verifyUploadDownloadSpeed_android(request, setup_perfectoMobile_android, connData)
+
+        #Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        #ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.fiveg
+    def test_PassPointConnection_5g_Open_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.twog
+    def test_PassPointConnection_2g_Open_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
--- a/tests/e2e/interOp/android/WifiMode/test_ToggleWifiMode.py
+++ b/tests/e2e/interOp/android/WifiMode/test_ToggleWifiMode.py
@@ -16,9 +16,11 @@ import allure
 if 'perfecto_libs' not in sys.path:
    sys.path.append(f'../libs/perfecto_libs')

-pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.interop_and, pytest.mark.android, pytest.mark.ToggleWifiMode]
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.interop_and, pytest.mark.android,
+              pytest.mark.ToggleWifiMode]

-from android_lib import closeApp, set_APconnMobileDevice_android, Toggle_WifiMode_android, Toggle_AirplaneMode_android, ForgetWifiConnection, openApp
+from android_lib import closeApp, set_APconnMobileDevice_android, Toggle_WifiMode_android, Toggle_AirplaneMode_android, \
+    ForgetWifiConnection, openApp

 setup_params_general = {
    "mode": "NAT",
@@ -26,14 +28,17 @@ setup_params_general = {
        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
-                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}],
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+                 "security_key": "something"}],
        "wpa2_personal": [
            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
-            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}]},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
    "rf": {},
    "radius": False
 }

+
@allure.feature("NAT MODE CLIENT CONNECTIVITY")
@pytest.mark.parametrize(
    'setup_profiles',
@@ -41,13 +46,122 @@ setup_params_general = {
    indirect=True,
    scope="class"
 )
-
@pytest.mark.usefixtures("setup_profiles")
 class TestToggleWifiMode(object):

+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_5g_WPA2_Personal(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_2g_WPA2_Personal(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_5g_WPA(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_2g_WPA(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
    @pytest.mark.open
    @pytest.mark.fiveg
-    def test_ToogleAirplaneMode_5g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+    def test_ToogleWifiMode_5g_OPEN(self, request, get_vif_state, get_ToggleWifiMode_data,
                                        setup_perfectoMobile_android):

        profile_data = setup_params_general["ssid_modes"]["open"][1]
@@ -62,20 +176,20 @@ class TestToggleWifiMode(object):

        report = setup_perfectoMobile_android[1]
        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
+        connData = get_ToggleWifiMode_data

        # Set Wifi/AP Mode
        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)

-        # Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)

        # ForgetWifi
        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)

    @pytest.mark.open
    @pytest.mark.twog
-    def test_ToogleAirplaneMode_2g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+    def test_ToogleWifiMode_2g_OPEN(self, request, get_vif_state, get_ToggleWifiMode_data,
                                        setup_perfectoMobile_android):

        profile_data = setup_params_general["ssid_modes"]["open"][0]
@@ -90,122 +204,13 @@ class TestToggleWifiMode(object):

        report = setup_perfectoMobile_android[1]
        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleAirplaneMode_data
+        connData = get_ToggleWifiMode_data

        # Set Wifi/AP Mode
        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)

-        # Toggle AirplaneMode
-        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)

        # ForgetWifi
        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-
-    @pytest.mark.fiveg
-    @pytest.mark.wpa2_personal
-    def test_ToogleWifiMode_5g_WPA2_Personal(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
-
-        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = profile_data["security_key"]
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleWifiMode_data
-
-        #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle Wifi Mode
-        Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
-
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-    @pytest.mark.twog
-    @pytest.mark.wpa2_personal
-    def test_ToogleWifiMode_2g_WPA2_Personal(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
-        
-        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0] 
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = profile_data["security_key"]
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleWifiMode_data
-
-        #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle Wifi Mode
-        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
-    
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-    @pytest.mark.fiveg
-    @pytest.mark.wpa
-    def test_ToogleWifiMode_5g_WPA(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
-         
-        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = profile_data["security_key"]
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleWifiMode_data
-
-        #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle Wifi Mode
-        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
-    
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
-
-    @pytest.mark.twog
-    @pytest.mark.wpa
-    def test_ToogleWifiMode_2g_WPA(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
-         
-        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
-        ssidName = profile_data["ssid_name"]
-        ssidPassword = profile_data["security_key"]
-        print ("SSID_NAME: " + ssidName)
-        print ("SSID_PASS: " + ssidPassword)
-
-        if ssidName not in get_vif_state:
-            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
-            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
-
-        report = setup_perfectoMobile_android[1]
-        driver = setup_perfectoMobile_android[0]
-        connData = get_ToggleWifiMode_data
-
-        #Set Wifi/AP Mode
-        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
-
-        #Toggle Wifi Mode
-        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
-    
-        #ForgetWifi
-        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
--- a/tests/e2e/interOp/android/WifiMode/test_WifiMode_BridgeMode.py
+++ b/tests/e2e/interOp/android/WifiMode/test_WifiMode_BridgeMode.py
@@ -0,0 +1,216 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+
+import sys
+import allure
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.interop_and, pytest.mark.android,
+              pytest.mark.ToggleWifiMode]
+
+from android_lib import closeApp, set_APconnMobileDevice_android, Toggle_WifiMode_android, Toggle_AirplaneMode_android, \
+    ForgetWifiConnection, openApp
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+                 "security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+@pytest.mark.usefixtures("setup_profiles")
+class TestToggleWifiModeBridge(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_5g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_2g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle Wifi Mode
+        assert Toggle_WifiMode_android(request, setup_perfectoMobile_android, ssidName, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.fiveg
+    def test_ToogleWifiMode_5g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.twog
+    def test_ToogleWifiMode_2g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                        setup_perfectoMobile_android):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_android[1]
+        driver = setup_perfectoMobile_android[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_android(request, ssidName, ssidPassword, setup_perfectoMobile_android, connData)
+
+        # Toggle AirplaneMode
+        assert Toggle_AirplaneMode_android(request, setup_perfectoMobile_android, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_android, ssidName, connData)
--- a/tests/e2e/interOp/conftest.py
+++ b/tests/e2e/interOp/conftest.py
@@ -339,31 +339,37 @@ def pytest_runtest_makereport(item, call):


 def pytest_sessionfinish(session, exitstatus):
-    print()
-    skipped_amount = 0
-    # print('Perfecto TestCase Execution Status:', exitstatus)
-    passed_amount = sum(1 for result in session.results.values() if result.passed)
-    failed_amount = sum(1 for result in session.results.values() if result.failed)
-    skipped_amount = sum(1 for result in session.results.values() if result.skipped)
-    #  print(f'There are {passed_amount} passed and {failed_amount} failed tests')
-    TotalExecutedCount = failed_amount + passed_amount + skipped_amount
-
-    print('\n------------------------------------')
-    print('Interop Perfecto TestCase Execution Summary')
-    print('------------------------------------')
-    print('Total TestCase Executed: ' + str(TotalExecutedCount))
-    print('Total Passed: ' + str(passed_amount))
-    print('Total Failed: ' + str(failed_amount))
-    print('Total Skipped: ' + str(skipped_amount) + "\n")

    try:
-        for index in range(len(testCaseNameList)):
-            print(str(index + 1) + ") " + str(testCaseNameList[index]) + " : " + str(testCaseStatusList[index]))
-            print("     ReportURL: " + str(testCaseReportURL[index]))
-            print("     FailureMsg: " + str(testCaseErrorMsg[index]) + "\n")
-    except Exception as e:
-        print('No Interop Test Cases Executed')
+        if reporting_client is not None:
+            print()
+            skipped_amount = 0
+            # print('Perfecto TestCase Execution Status:', exitstatus)
+            passed_amount = sum(1 for result in session.results.values() if result.passed)
+            failed_amount = sum(1 for result in session.results.values() if result.failed)
+            skipped_amount = sum(1 for result in session.results.values() if result.skipped)
+            #  print(f'There are {passed_amount} passed and {failed_amount} failed tests')
+            TotalExecutedCount = failed_amount + passed_amount + skipped_amount

+            print('\n------------------------------------')
+            print('TestCase Execution Summary')
+            print('------------------------------------')
+            print('Total TestCase Executed: ' + str(TotalExecutedCount))
+            print('Total Passed: ' + str(passed_amount))
+            print('Total Failed: ' + str(failed_amount))
+            print('Total Skipped: ' + str(skipped_amount) + "\n")
+            try:
+                for index in range(len(testCaseNameList)):
+                    print(str(index + 1) + ") " + str(testCaseNameList[index]) + " : " + str(testCaseStatusList[index]))
+                    print("     ReportURL: " + str(testCaseReportURL[index]))
+                    print("     FailureMsg: " + str(testCaseErrorMsg[index]) + "\n")
+            except Exception as e:
+                print('No Interop Test Cases Executed')
+        else:
+            pass
+
+    except Exception as e:
+        pass
    print('------------------------------------------------------------------\n\n\n\n')


--- a/tests/e2e/interOp/iOS/AirplaneMode/test_ToggleAirplaneMode.py
+++ b/tests/e2e/interOp/iOS/AirplaneMode/test_ToggleAirplaneMode.py
@@ -25,6 +25,8 @@ pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.ios, pytest.m
 setup_params_general = {
    "mode": "NAT",
    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
                 "security_key": "something"}],
@@ -68,12 +70,12 @@ class TestToggleAirplaneMode(object):
        # Set Wifi/AP Mode
        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
        # print("ReportFlag: " + resultFlag)
-        # setReportResultFlag(resultFlag)
+        # setReportResultFlag(resultFlag).

        # Toggle AirplaneMode
        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)

-        # Verify AP After AirplaneMode
+        # Verify AP After AirplaneMode.
        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)

        # ForgetWifi
@@ -171,3 +173,68 @@ class TestToggleAirplaneMode(object):

        # ForgetWifi
        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.fiveg
+    def test_ToogleAirplaneMode_5g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ReportFlag: " + resultFlag)
+        # setReportResultFlag(resultFlag)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.twog
+    def test_ToogleAirplaneMode_2g_OPEN(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ReportFlag: " + resultFlag)
+        # setReportResultFlag(resultFlag)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
--- a/tests/e2e/interOp/iOS/AirplaneMode/test_ToggleAirplaneMode_BridgeMode.py
+++ b/tests/e2e/interOp/iOS/AirplaneMode/test_ToggleAirplaneMode_BridgeMode.py
@@ -0,0 +1,240 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+
+import sys
+import allure
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+from iOS_lib import closeApp, openApp, Toggle_AirplaneMode_iOS, ForgetWifiConnection, set_APconnMobileDevice_iOS, \
+    verify_APconnMobileDevice_iOS, Toggle_WifiMode_iOS, tearDown
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.ios, pytest.mark.interop_ios,
+              pytest.mark.ToggleAirplaneMode]
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+                 "security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+@pytest.mark.usefixtures("setup_profiles")
+class TestToggleAirplaneModeBridgeMode(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_ToogleAirplaneMode_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                                 setup_perfectoMobile_iOS):
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ReportFlag: " + resultFlag)
+        # setReportResultFlag(resultFlag)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_ToogleAirplaneMode_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                                 setup_perfectoMobile_iOS):
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ResultFlag: " + resultFlag)
+        # print(resultFlag)
+        # reportResultFlag.reportFlag = resultFlag
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_ToogleAirplaneMode_5g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                       setup_perfectoMobile_iOS):
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_ToogleAirplaneMode_2g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data,
+                                       setup_perfectoMobile_iOS):
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+    @pytest.mark.open
+    @pytest.mark.fiveg
+    def test_ToogleAirplaneMode_5g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ReportFlag: " + resultFlag)
+        # setReportResultFlag(resultFlag)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.open
+    @pytest.mark.twog
+    def test_ToogleAirplaneMode_2g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleAirplaneMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print ("SSID_NAME: " + ssidName)
+        print ("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleAirplaneMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+        # print("ReportFlag: " + resultFlag)
+        # setReportResultFlag(resultFlag)
+
+        # Toggle AirplaneMode
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        assert verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
--- a/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_BridgeMode.py
+++ b/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_BridgeMode.py
@@ -74,12 +74,14 @@ class TestOpenRoamingBridge(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -137,12 +139,14 @@ class TestOpenRoamingBridge(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -206,12 +210,14 @@ class TestOpenRoamingBridge(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -269,12 +275,14 @@ class TestOpenRoamingBridge(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
--- a/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_NatMode.py
+++ b/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_NatMode.py
@@ -75,12 +75,14 @@ class TestOpenRoamingNAT(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -145,12 +147,14 @@ class TestOpenRoamingNAT(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -219,12 +223,14 @@ class TestOpenRoamingNAT(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -293,12 +299,14 @@ class TestOpenRoamingNAT(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
--- a/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_vlan_mode.py
+++ b/tests/e2e/interOp/iOS/OpenRoamingPassPoint/test_OpenRoaming_vlan_mode.py
@@ -74,12 +74,14 @@ class TestOpenRoamingBridgeVLAN(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -137,12 +139,14 @@ class TestOpenRoamingBridgeVLAN(object):
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -206,12 +210,14 @@ class TestOpenRoamingBridgeVLAN(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_2g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_2g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
@@ -269,12 +275,14 @@ class TestOpenRoamingBridgeVLAN(object):
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config push to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result
        result = push_ap_profile['ssid_wpa2_only_eap_passpoint_5g']['vif_state']
        if result:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g successful ", body="")
        else:
            allure.attach(name="Config apply to AP for ssid_wpa2_only_eap_passpoint_5g failed", body="")
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
        assert result

        print("SSID to download profile :: ", setup_params_eap["ssid_modes"]["open"][0]["ssid_name"])
--- a/tests/e2e/interOp/iOS/PassPoint/test_PassPointConnection.py
+++ b/tests/e2e/interOp/iOS/PassPoint/test_PassPointConnection.py
@@ -24,6 +24,8 @@ from iOS_lib import closeApp, openApp, Toggle_AirplaneMode_iOS, ForgetWifiConnec
 setup_params_general = {
    "mode": "NAT",
    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}],
        "wpa2_personal": [
@@ -167,4 +169,66 @@ class TestPassPointConnection(object):
        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)

        # Close Settings App
-        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.fiveg
+    @pytest.mark.open
+    def test_PassPointConnection_5g_OPEN(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        assert Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi.
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.twog
+    @pytest.mark.Open
+    def test_PassPointConnection_2g_OPEN(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b.
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App.
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
--- a/tests/e2e/interOp/iOS/PassPoint/test_PassPointConnection_BridgeMode.py
+++ b/tests/e2e/interOp/iOS/PassPoint/test_PassPointConnection_BridgeMode.py
@@ -0,0 +1,234 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+from urllib3 import exceptions
+
+import sys
+import allure
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.interop_ios, pytest.mark.ios, pytest.mark.PassPointConnection]
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+from iOS_lib import closeApp, openApp, Toggle_AirplaneMode_iOS, ForgetWifiConnection, set_APconnMobileDevice_iOS, verify_APconnMobileDevice_iOS, Toggle_WifiMode_iOS, tearDown
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],"security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+@pytest.mark.usefixtures("setup_profiles")
+class TestPassPointConnectionBridgeMode(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_PassPointConnection_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        assert Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_PassPointConnection_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b.
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App.
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_PassPointConnection_2g_WPA_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                        get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_PassPointConnection_5g_WPA_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                        get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_open
+    def test_PassPointConnection_5g_OPEN_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        assert Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
+
+    @pytest.mark.twog
+    @pytest.mark.open
+    def test_PassPointConnection_2g_OPEN_BRIDGE(self, request, get_vif_state, setup_perfectoMobile_iOS,
+                                                  get_PassPointConniOS_data):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_PassPointConniOS_data
+
+        # Set Wifi Access Mode to #Default-SSID-5gl-perfecto-b/#Default-SSID-2gl-perfecto-b.
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle Airplane Mode and Ensure Wifi Connection.
+        Toggle_AirplaneMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+        # Close Settings App.
+        closeApp(connData["bundleId-iOS-Settings"], setup_perfectoMobile_iOS)
--- a/tests/e2e/interOp/iOS/WifiMode/test_ToggleWifiMode.py
+++ b/tests/e2e/interOp/iOS/WifiMode/test_ToggleWifiMode.py
@@ -25,6 +25,8 @@ from iOS_lib import closeApp, openApp, Toggle_AirplaneMode_iOS, ForgetWifiConnec
 setup_params_general = {
    "mode": "NAT",
    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
                 "security_key": "something"}],
@@ -170,5 +172,67 @@ class TestToggleWifiMode(object):
        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
        assert value

+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.open
+    def test_ToogleWifiMode_5g_OPEN(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.open
+    def test_ToogleWifiMode_2g_OPEN(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode.
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
        # ForgetWifi
        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
--- a/tests/e2e/interOp/iOS/WifiMode/test_ToggleWifiMode_Bridge.py
+++ b/tests/e2e/interOp/iOS/WifiMode/test_ToggleWifiMode_Bridge.py
@@ -0,0 +1,238 @@
+from logging import exception
+import unittest
+import warnings
+from perfecto.test import TestResultFactory
+import pytest
+import sys
+import time
+from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.common.by import By
+from appium import webdriver
+from selenium.common.exceptions import NoSuchElementException
+
+import sys
+import allure
+
+if 'perfecto_libs' not in sys.path:
+    sys.path.append(f'../libs/perfecto_libs')
+
+pytestmark = [pytest.mark.sanity, pytest.mark.interop, pytest.mark.ios, pytest.mark.interop_ios,
+              pytest.mark.ToggleWifiMode]
+
+from iOS_lib import closeApp, openApp, Toggle_AirplaneMode_iOS, ForgetWifiConnection, set_APconnMobileDevice_iOS, \
+    verify_APconnMobileDevice_iOS, Toggle_WifiMode_iOS, tearDown
+
+setup_params_general = {
+    "mode": "BRIDGE",
+    "ssid_modes": {
+        "open": [{"ssid_name": "ssid_open_2g", "appliedRadios": ["is2dot4GHz"]},
+                 {"ssid_name": "ssid_open_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"]}],
+        "wpa": [{"ssid_name": "ssid_wpa_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+                {"ssid_name": "ssid_wpa_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+                 "security_key": "something"}],
+        "wpa2_personal": [
+            {"ssid_name": "ssid_wpa2_2g", "appliedRadios": ["is2dot4GHz"], "security_key": "something"},
+            {"ssid_name": "ssid_wpa2_5g", "appliedRadios": ["is5GHzU", "is5GHz", "is5GHzL"],
+             "security_key": "something"}]},
+    "rf": {},
+    "radius": False
+}
+
+
+@allure.feature("BRIDGE MODE CLIENT CONNECTIVITY")
+@pytest.mark.parametrize(
+    'setup_profiles',
+    [setup_params_general],
+    indirect=True,
+    scope="class"
+)
+@pytest.mark.usefixtures("setup_profiles")
+class TestToggleWifiModeBridgeMode(object):
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_5g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa2_personal
+    def test_ToogleWifiMode_2g_WPA2_Personal_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data,
+                                             setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa2_personal"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode.
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode.
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi.
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_5g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.wpa
+    def test_ToogleWifiMode_2g_WPA_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["wpa"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = profile_data["security_key"]
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.fiveg
+    @pytest.mark.open
+    def test_ToogleWifiMode_5g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][1]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
+
+    @pytest.mark.twog
+    @pytest.mark.open
+    def test_ToogleWifiMode_2g_OPEN_BRIDGE(self, request, get_vif_state, get_ToggleWifiMode_data, setup_perfectoMobile_iOS):
+
+        profile_data = setup_params_general["ssid_modes"]["open"][0]
+        ssidName = profile_data["ssid_name"]
+        ssidPassword = "[BLANK]"
+        print("SSID_NAME: " + ssidName)
+        print("SSID_PASS: " + ssidPassword)
+
+        if ssidName not in get_vif_state:
+            allure.attach(name="retest,vif state ssid not available:", body=str(get_vif_state))
+            pytest.xfail("SSID NOT AVAILABLE IN VIF STATE")
+
+        report = setup_perfectoMobile_iOS[1]
+        driver = setup_perfectoMobile_iOS[0]
+        connData = get_ToggleWifiMode_data
+
+        # Set Wifi/AP Mode
+        set_APconnMobileDevice_iOS(request, ssidName, ssidPassword, setup_perfectoMobile_iOS, connData)
+
+        # Toggle WifiMode
+        Toggle_WifiMode_iOS(request, setup_perfectoMobile_iOS, connData)
+
+        # Verify AP After AirplaneMode
+        value = verify_APconnMobileDevice_iOS(request, ssidName, setup_perfectoMobile_iOS, connData)
+        assert value
+
+        # ForgetWifi
+        ForgetWifiConnection(request, setup_perfectoMobile_iOS, ssidName, connData)
--- a/tests/fixtures_2x.py
+++ b/tests/fixtures_2x.py
@@ -255,6 +255,7 @@ class Fixtures_2x:
        if x < 19:
            print("Config properly applied into AP", config)

+
        time_2 = time.time()
        time_interval = time_2 - time_1
        allure.attach(name="Time Took to apply Config: " + str(time_interval), body="")
@@ -262,6 +263,7 @@ class Fixtures_2x:
        ap_config_latest = ap_ssh.get_uc_latest_config()
        ap_config_latest["uuid"] = 0

+
        ap_config_active = ap_ssh.get_uc_active_config()
        ap_config_active["uuid"] = 0
        x = 1
@@ -292,10 +294,13 @@ class Fixtures_2x:
            ssid_info_sdk = instantiate_profile_obj.get_ssid_info()
            ap_wifi_data = ap_ssh.get_iwinfo()

+
            for p in ap_wifi_data:
                for q in ssid_info_sdk:
                    if ap_wifi_data[p][0] == q[0] and ap_wifi_data[p][2] == q[3]:
                        q.append(ap_wifi_data[p][1])
+
+
            ssid_data = []
            idx_mapping = {}
            for interface in range(len(ssid_info_sdk)):
@@ -318,9 +323,11 @@ class Fixtures_2x:
        except Exception as e:
            print(e)
            pass
+
        def teardown_session():
            ap_logs = ap_ssh.logread()
            allure.attach(body=ap_logs, name="AP Logs after test completion")
            print("\nTeardown")
+
        request.addfinalizer(teardown_session)
        return test_cases
--- a/tools/pdu.json
+++ b/tools/pdu.json
@@ -0,0 +1,14 @@
+{
+  "basic-01":
+  {
+    "host": "192.168.200.49",
+    "username": "admin",
+    "password": "Lanforge12345!"
+  },
+    "basic-02":
+  {
+    "host": "192.168.200.49",
+    "username": "admin",
+    "password": "Lanforge12345!"
+  }
+}
--- a/tools/pdu_automation.py
+++ b/tools/pdu_automation.py
@@ -1,5 +1,13 @@
+#!/usr/bin/env python3
+"""
+Note: Please ensure that PDU is powered on.
+    Command line to be used as
+    python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action on/off/cycle --port all/specific_port_name
+    Eg 1: python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action off --port 'Outlet 1'
+    Eg 2: python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action cycle --port all
+"""
 import os
-import pprint
+import json
 import time
 import argparse
 from typing import Sequence
@@ -13,11 +21,14 @@ except:


 class setup:
-    def __init__(self, hostname, user, password):
-        self.hostname = hostname
-        self.user = user
-        self.password = password
-        self.power_switch = dlipower.PowerSwitch(hostname=self.hostname, userid=self.user, password=self.password)
+    try:
+        def __init__(self, hostname, user, password):
+            self.hostname = hostname
+            self.user = user
+            self.password = password
+            self.power_switch = dlipower.PowerSwitch(hostname=self.hostname, userid=self.user, password=self.password)
+    except:
+        print('PDU device is Off')


 class switch_on(setup):
@@ -64,11 +75,7 @@ def main(argv: Optional[Sequence[str]] = None):
    parser.add_argument('--host', help='Please provide host name eg: 192.168.200.65')
    parser.add_argument('--username', help='Please provide username eg: admin')
    parser.add_argument('--password', help='Please provide password eg: 1234')
-    parser.add_argument('--action', help='Switches all Outlets in ON Mode eg: --on_all\n'
-                                         'Switches all Outlets in OFF Mode eg: --off_all\n'
-                                         'Cycle all Outlets in OFF Mode and then ON Mode eg: --cycle_all\n'
-                                         'Switches the target Outlets in ON Mode eg: --on\n'
-                                         'Switches the target Outlets in OFF Mode --off\n')
+    parser.add_argument('--action', help='Switches all Outlets in ON Mode eg: --on or --off\n')
    parser.add_argument('--port', help='Please provide port name eg: --port lanforge')
    args = parser.parse_args(argv)
    dic = vars(args)
@@ -90,8 +97,3 @@ def main(argv: Optional[Sequence[str]] = None):

 if __name__ == '__main__':
    main()
-
-# Command line to be used as
-# python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action on --port all
-# python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action off --port 'Outlet 1'
-# python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action cycle --port all
--- a/tools/pdu_v2.py
+++ b/tools/pdu_v2.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""
+Date: 12-08-2021
+By: Amrit Raj @ Candela Technologies Pvt. ltd.
+Note: Please ensure that PDU is powered on.
+    Command line to be used as
+    python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action on/off/cycle --port all/specific_port_name
+    Eg 1: python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action off --port 'Outlet 1'
+    Eg 2: python pdu_automation.py --host 192.168.200.90 --user admin --password 1234 --action cycle --port all
+"""
+import os
+import json
+import time
+import argparse
+from typing import Sequence
+from typing import Optional
+
+try:
+    import dlipower
+except:
+    print('Please wait we are installing DLI Power')
+    os.system('pip install dlipower')
+
+
+class setup:
+    try:
+        def __init__(self, hostname, user, password):
+            self.hostname = hostname
+            self.user = user
+            self.password = password
+            self.power_switch = dlipower.PowerSwitch(hostname=self.hostname, userid=self.user, password=self.password)
+    except:
+        print('PDU device is Off')
+
+
+class switch_on(setup):
+    def __init__(self, hostname, user, password, port=None):
+        super().__init__(hostname, user, password)
+        self.port = port
+        if self.port != 'all':
+            self.i = 0
+            for i in self.power_switch:
+                # print(i.description)
+                if i.description == self.port:
+                    self.power_switch[self.i].state = "ON"
+                self.i += 1
+        else:
+            for outlet in self.power_switch:
+                outlet.state = 'ON'
+
+
+class switch_off(setup):
+    def __init__(self, hostname, user, password, port=None):
+        super().__init__(hostname, user, password)
+        self.port = port
+        if self.port != 'all':
+            self.i = 0
+            for i in self.power_switch:
+                # print(i.description)
+                if i.description == self.port:
+                    self.power_switch[self.i].state = "OFF"
+                self.i += 1
+            # self.power_switch[int(self.port)-1].state = "OFF"
+        else:
+            for outlet in self.power_switch:
+                outlet.state = 'OFF'
+
+
+class print_status(setup):
+    def __init__(self, hostname, user, password):
+        super().__init__(hostname, user, password)
+        print(self.power_switch)
+
+
+def main(argv: Optional[Sequence[str]] = None):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--testbed', help='Input the pdu name eg: basic-01 or basic-02\n')
+    parser.add_argument('--action', help='Switches all Outlets in ON Mode eg: on or off\n')
+    parser.add_argument('--port', help='Please provide port name eg: --port lanforge')
+    args = parser.parse_args(argv)
+    argument1 = vars(args)
+    testbed = argument1['testbed']
+    f = open('pdu.json')
+    y = json.load(f)
+    argument2 = y[testbed]
+    dic = {**argument1, **argument2}  # Dictionay Merging
+    # print(dic)
+    if dic['action'] == 'on':
+        set = setup(dic['host'], dic['username'], dic['password'])
+        on = switch_on(dic['host'], dic['username'], dic['password'], dic['port'])
+    elif dic['action'] == 'off':
+        set = setup(dic['host'], dic['username'], dic['password'])
+        off = switch_off(dic['host'], dic['username'], dic['password'], dic['port'])
+        # off = switch_on(dic['action'])
+    elif dic['action'] == 'cycle':
+        set = setup(dic['host'], dic['username'], dic['password'])
+        on = switch_off(dic['host'], dic['username'], dic['password'], dic['port'])
+        off = switch_on(dic['host'], dic['username'], dic['password'], dic['port'])
+    else:
+        print('Command not found')
+
+
+if __name__ == '__main__':
+    main()