From 165aa7afe0806fbdb23ae1f22768daceaecbd98d Mon Sep 17 00:00:00 2001
From: Shiven Chawla <chawls@uw.edu>
Date: Fri, 9 Dec 2022 09:28:06 -0800
Subject: [PATCH] develop workflow for test coverage badge (#76)

Co-authored-by: Shiven Chawla <shivenchawla@microsoft.com>
---
 .github/workflows/testcoverage.yaml |   35 +
 .gitignore                          |    1 +
 README.md                           |    1 +
 coverage.json                       | 3027 +++++++++++++++++++++++++++
 4 files changed, 3064 insertions(+)
 create mode 100644 .github/workflows/testcoverage.yaml
 create mode 100644 coverage.json

diff --git a/.github/workflows/testcoverage.yaml b/.github/workflows/testcoverage.yaml
new file mode 100644
index 0000000..a9e91cd
--- /dev/null
+++ b/.github/workflows/testcoverage.yaml
@@ -0,0 +1,35 @@
+---
+name: Generate PyTest Coverage Badge
+on:
+  pull_request:
+    types:
+      - closed
+
+jobs:
+  coverage_if_merged:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Counterfit repository
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+
+      - name: Get Coverage Percentage
+        id: coverage_percent
+        uses: notiz-dev/github-action-json-property@release
+        with: 
+            path: 'coverage.json'
+            prop_path: 'totals.percent_covered_display'
+      - run: echo ${{steps.coverage_percent.outputs.prop}}
+
+      - name: Create Coverage Badge
+        uses: schneegans/dynamic-badges-action@v1.6.0
+        with:
+          auth: ${{ secrets.COUNTERFITGISTTOKEN }}
+          gistID: 67510f61f4c4c8809985712453ff1ad8
+          filename: counterfit_test_coverage_badge.json
+          label: Coverage
+          message: ${{steps.coverage_percent.outputs.prop}}%
+          color: orange
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index 569b57e..b0ce2e9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -46,6 +46,7 @@ pip-delete-this-directory.txt
 # Unit test / coverage reports
 htmlcov/
 .tox/
+.coverage
 .coverage.*
 .cache
 nosetests.xml
diff --git a/README.md b/README.md
index 9696bb6..6c6c21e 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # Counterfit
 
 [![Tests](https://github.com/Azure/counterfit/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/Azure/counterfit/actions/workflows/tests.yaml)
+![TestCoverageBadge](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/shivenchawla/67510f61f4c4c8809985712453ff1ad8/raw/counterfit_test_coverage_badge.json)
 [![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/Azure/counterfit/blob/main/LICENSE)
 
 [About](#About) | [Getting Started](#Getting-Started) | [Acknowledgments](#Acknowledgments) | [Contributing](#Contributing) | [Trademarks](#Trademarks) | [Contact Us](#Contact-Us)
diff --git a/coverage.json b/coverage.json
new file mode 100644
index 0000000..c846dc5
--- /dev/null
+++ b/coverage.json
@@ -0,0 +1,3027 @@
+{
+    "meta": {
+        "version": "6.5.0",
+        "timestamp": "2022-12-08T12:50:25.583747",
+        "branch_coverage": false,
+        "show_contexts": false
+    },
+    "files": {
+        "conftest.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                7,
+                8,
+                10,
+                12,
+                13,
+                15,
+                16,
+                17,
+                18,
+                20,
+                21,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28
+            ],
+            "summary": {
+                "covered_lines": 22,
+                "num_statements": 22,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\__init__.py": {
+            "executed_lines": [
+                1,
+                2,
+                5,
+                6,
+                7,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                19,
+                20
+            ],
+            "summary": {
+                "covered_lines": 15,
+                "num_statements": 15,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 1,
+                "num_statements": 1,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\attacks.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                5,
+                7,
+                8,
+                9,
+                10,
+                13,
+                14,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                26,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                46,
+                47,
+                50,
+                51,
+                52,
+                55,
+                56,
+                57,
+                58,
+                59,
+                62,
+                63,
+                66,
+                67,
+                68,
+                69,
+                72,
+                73,
+                76,
+                77,
+                78,
+                80,
+                81,
+                83,
+                84,
+                86,
+                87,
+                89,
+                90,
+                91,
+                92,
+                94,
+                95,
+                97,
+                109
+            ],
+            "summary": {
+                "covered_lines": 59,
+                "num_statements": 76,
+                "percent_covered": 77.63157894736842,
+                "percent_covered_display": "78",
+                "missing_lines": 17,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                98,
+                100,
+                101,
+                103,
+                104,
+                105,
+                107,
+                110,
+                120,
+                121,
+                123,
+                124,
+                126,
+                127,
+                128,
+                130,
+                131
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\core.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                16,
+                19,
+                20,
+                29,
+                30,
+                31,
+                32,
+                34,
+                35,
+                36,
+                38,
+                40,
+                41,
+                42,
+                44,
+                45,
+                47,
+                49,
+                50,
+                60,
+                61,
+                72,
+                73,
+                76,
+                77,
+                79,
+                80,
+                100,
+                102,
+                103,
+                104,
+                105,
+                111,
+                119,
+                120,
+                129,
+                130,
+                142,
+                144,
+                145,
+                159,
+                162,
+                165,
+                168,
+                169,
+                170,
+                172,
+                174,
+                175,
+                176,
+                181,
+                185,
+                188,
+                191,
+                194,
+                197,
+                200,
+                201
+            ],
+            "summary": {
+                "covered_lines": 70,
+                "num_statements": 89,
+                "percent_covered": 78.65168539325843,
+                "percent_covered_display": "79",
+                "missing_lines": 19,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                70,
+                71,
+                74,
+                75,
+                106,
+                107,
+                108,
+                109,
+                112,
+                113,
+                114,
+                115,
+                123,
+                124,
+                125,
+                126,
+                138,
+                139,
+                140
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\frameworks.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                7,
+                8,
+                11,
+                12,
+                15,
+                16,
+                19,
+                20
+            ],
+            "summary": {
+                "covered_lines": 10,
+                "num_statements": 14,
+                "percent_covered": 71.42857142857143,
+                "percent_covered_display": "71",
+                "missing_lines": 4,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                9,
+                13,
+                17,
+                21
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\logger.py": {
+            "executed_lines": [
+                1,
+                3,
+                6,
+                7,
+                9,
+                11,
+                15,
+                16,
+                18,
+                19,
+                20,
+                22,
+                23,
+                26,
+                27,
+                29,
+                38,
+                47,
+                51,
+                56,
+                60
+            ],
+            "summary": {
+                "covered_lines": 18,
+                "num_statements": 33,
+                "percent_covered": 54.54545454545455,
+                "percent_covered_display": "55",
+                "missing_lines": 15,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                12,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                36,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                57
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\options.py": {
+            "executed_lines": [
+                1,
+                2,
+                5,
+                6,
+                10,
+                11,
+                13,
+                14,
+                15,
+                36,
+                37,
+                38,
+                39,
+                42,
+                49,
+                50,
+                51,
+                52,
+                59,
+                60,
+                62
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 31,
+                "percent_covered": 64.51612903225806,
+                "percent_covered_display": "65",
+                "missing_lines": 11,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                53,
+                54,
+                55,
+                57,
+                68,
+                69,
+                70,
+                72,
+                73,
+                75,
+                76
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\output.py": {
+            "executed_lines": [
+                1,
+                3,
+                5,
+                6,
+                7,
+                15,
+                16,
+                22,
+                24,
+                25,
+                33,
+                34,
+                40,
+                42,
+                43
+            ],
+            "summary": {
+                "covered_lines": 15,
+                "num_statements": 18,
+                "percent_covered": 83.33333333333333,
+                "percent_covered_display": "83",
+                "missing_lines": 3,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                13,
+                31,
+                49
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\reporting.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5,
+                6,
+                7,
+                9,
+                10,
+                11,
+                14,
+                15,
+                18,
+                29,
+                70
+            ],
+            "summary": {
+                "covered_lines": 14,
+                "num_statements": 72,
+                "percent_covered": 19.444444444444443,
+                "percent_covered_display": "19",
+                "missing_lines": 58,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                12,
+                16,
+                19,
+                20,
+                23,
+                24,
+                27,
+                37,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                52,
+                53,
+                54,
+                55,
+                77,
+                79,
+                80,
+                81,
+                82,
+                83,
+                84,
+                86,
+                87,
+                88,
+                89,
+                94,
+                95,
+                97,
+                98,
+                100,
+                101,
+                102,
+                103,
+                104,
+                105,
+                106,
+                107,
+                108,
+                113,
+                116,
+                117,
+                118,
+                119,
+                120,
+                121,
+                122
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\targets.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                9,
+                11,
+                12,
+                15,
+                16,
+                18,
+                19,
+                20,
+                21,
+                22,
+                24,
+                25,
+                26,
+                27,
+                29,
+                30,
+                32,
+                33,
+                41,
+                42,
+                50,
+                61,
+                72,
+                80,
+                81,
+                83,
+                85,
+                86,
+                87,
+                88,
+                89,
+                90,
+                91,
+                98,
+                103,
+                105,
+                114,
+                115,
+                116,
+                118,
+                127,
+                128,
+                129,
+                131,
+                140,
+                141,
+                143,
+                154
+            ],
+            "summary": {
+                "covered_lines": 54,
+                "num_statements": 75,
+                "percent_covered": 72.0,
+                "percent_covered_display": "72",
+                "missing_lines": 21,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                39,
+                48,
+                62,
+                64,
+                66,
+                67,
+                70,
+                71,
+                75,
+                76,
+                99,
+                100,
+                101,
+                152,
+                155,
+                160,
+                161,
+                162,
+                163,
+                164,
+                166
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\core\\utils.py": {
+            "executed_lines": [
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                13,
+                31,
+                37,
+                40,
+                70,
+                75,
+                79,
+                83,
+                95,
+                99,
+                105,
+                108,
+                125,
+                141
+            ],
+            "summary": {
+                "covered_lines": 24,
+                "num_statements": 70,
+                "percent_covered": 34.285714285714285,
+                "percent_covered_display": "34",
+                "missing_lines": 46,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                28,
+                50,
+                52,
+                53,
+                54,
+                56,
+                57,
+                58,
+                60,
+                62,
+                63,
+                64,
+                65,
+                66,
+                67,
+                72,
+                76,
+                80,
+                84,
+                86,
+                87,
+                88,
+                89,
+                91,
+                92,
+                96,
+                117,
+                118,
+                119,
+                120,
+                121,
+                122,
+                135,
+                136,
+                137,
+                138,
+                147,
+                148,
+                149,
+                151
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\data\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 1,
+                "num_statements": 1,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\data\\image.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                5,
+                6,
+                15,
+                16,
+                22,
+                23,
+                29,
+                30,
+                33,
+                34,
+                38,
+                39,
+                43,
+                44
+            ],
+            "summary": {
+                "covered_lines": 17,
+                "num_statements": 36,
+                "percent_covered": 47.22222222222222,
+                "percent_covered_display": "47",
+                "missing_lines": 19,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                7,
+                8,
+                9,
+                10,
+                12,
+                13,
+                17,
+                18,
+                20,
+                24,
+                25,
+                27,
+                31,
+                35,
+                36,
+                40,
+                41,
+                45,
+                46
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\__init__.py": {
+            "executed_lines": [
+                3,
+                5,
+                6,
+                7
+            ],
+            "summary": {
+                "covered_lines": 4,
+                "num_statements": 4,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\art\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\art\\art.py": {
+            "executed_lines": [
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                10,
+                11,
+                12,
+                13,
+                14,
+                16,
+                17,
+                18,
+                19,
+                21,
+                22,
+                23,
+                25,
+                26,
+                38,
+                39,
+                43,
+                44,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                53,
+                54,
+                57,
+                59,
+                60,
+                62,
+                63,
+                72,
+                76,
+                79,
+                80,
+                87,
+                143,
+                147,
+                149,
+                151,
+                152,
+                155,
+                158,
+                161,
+                162,
+                163,
+                167,
+                168,
+                169,
+                192,
+                194,
+                195,
+                196,
+                198,
+                199,
+                200,
+                202,
+                203,
+                206,
+                209,
+                223,
+                226,
+                227,
+                228,
+                229,
+                231,
+                232,
+                234,
+                235,
+                237,
+                238,
+                240,
+                243,
+                244,
+                248,
+                249,
+                251,
+                253,
+                254,
+                255,
+                256,
+                258,
+                277,
+                278,
+                280,
+                281,
+                282,
+                283
+            ],
+            "summary": {
+                "covered_lines": 95,
+                "num_statements": 154,
+                "percent_covered": 61.688311688311686,
+                "percent_covered_display": "62",
+                "missing_lines": 59,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                27,
+                28,
+                30,
+                31,
+                32,
+                34,
+                36,
+                88,
+                89,
+                90,
+                91,
+                93,
+                94,
+                95,
+                96,
+                98,
+                99,
+                100,
+                102,
+                104,
+                105,
+                110,
+                116,
+                117,
+                118,
+                125,
+                128,
+                130,
+                131,
+                133,
+                139,
+                164,
+                171,
+                172,
+                175,
+                176,
+                179,
+                181,
+                184,
+                186,
+                189,
+                191,
+                212,
+                213,
+                214,
+                218,
+                230,
+                241,
+                245,
+                246,
+                259,
+                261,
+                263,
+                265,
+                268,
+                270,
+                272,
+                273,
+                275
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\art\\utils.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                49,
+                93,
+                137,
+                141,
+                143,
+                144,
+                145,
+                146,
+                148,
+                149,
+                151,
+                154,
+                157,
+                160,
+                163,
+                166,
+                169,
+                172,
+                175,
+                178,
+                181,
+                184,
+                187,
+                190,
+                199,
+                200,
+                209,
+                211
+            ],
+            "summary": {
+                "covered_lines": 31,
+                "num_statements": 56,
+                "percent_covered": 55.357142857142854,
+                "percent_covered_display": "55",
+                "missing_lines": 25,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                152,
+                155,
+                158,
+                161,
+                164,
+                167,
+                170,
+                173,
+                176,
+                179,
+                182,
+                185,
+                220,
+                221,
+                222,
+                224,
+                225,
+                226,
+                227,
+                228,
+                229,
+                230,
+                231,
+                232,
+                234
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\augly\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\augly\\augly.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                10,
+                11,
+                12,
+                15,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                28,
+                29,
+                30,
+                31,
+                32,
+                35,
+                36,
+                37,
+                38,
+                39,
+                41,
+                44,
+                49,
+                70,
+                71,
+                72,
+                74,
+                75,
+                87,
+                88,
+                89,
+                91,
+                94,
+                96,
+                97,
+                100,
+                104,
+                108,
+                115,
+                118
+            ],
+            "summary": {
+                "covered_lines": 47,
+                "num_statements": 83,
+                "percent_covered": 56.626506024096386,
+                "percent_covered_display": "57",
+                "missing_lines": 36,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                16,
+                17,
+                18,
+                42,
+                43,
+                45,
+                46,
+                47,
+                53,
+                54,
+                57,
+                58,
+                59,
+                60,
+                62,
+                64,
+                67,
+                76,
+                77,
+                79,
+                80,
+                81,
+                83,
+                85,
+                98,
+                102,
+                106,
+                109,
+                116,
+                119,
+                120,
+                121,
+                122,
+                123,
+                125,
+                126
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\textattack\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\frameworks\\textattack\\textattack.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                7,
+                8,
+                10,
+                11,
+                14,
+                15,
+                18,
+                19,
+                30,
+                34,
+                53,
+                61,
+                65,
+                69,
+                76
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 52,
+                "percent_covered": 38.46153846153846,
+                "percent_covered_display": "38",
+                "missing_lines": 32,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                16,
+                20,
+                21,
+                23,
+                24,
+                25,
+                26,
+                28,
+                32,
+                41,
+                42,
+                43,
+                45,
+                46,
+                48,
+                49,
+                50,
+                51,
+                55,
+                57,
+                58,
+                59,
+                63,
+                67,
+                70,
+                77,
+                79,
+                80,
+                82,
+                83,
+                85,
+                86
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\reporting\\__init__.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5
+            ],
+            "summary": {
+                "covered_lines": 4,
+                "num_statements": 4,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\reporting\\image.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                5,
+                6,
+                7,
+                12,
+                13,
+                14,
+                17,
+                18,
+                20,
+                23,
+                24,
+                39,
+                40,
+                94,
+                95,
+                153,
+                154
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 123,
+                "percent_covered": 16.260162601626018,
+                "percent_covered_display": "16",
+                "missing_lines": 103,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                21,
+                25,
+                26,
+                27,
+                28,
+                29,
+                31,
+                32,
+                33,
+                35,
+                36,
+                37,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                52,
+                54,
+                55,
+                56,
+                60,
+                62,
+                63,
+                65,
+                67,
+                68,
+                70,
+                71,
+                74,
+                75,
+                76,
+                78,
+                79,
+                80,
+                81,
+                82,
+                83,
+                84,
+                85,
+                86,
+                87,
+                88,
+                89,
+                90,
+                92,
+                97,
+                98,
+                99,
+                102,
+                103,
+                104,
+                107,
+                109,
+                111,
+                112,
+                113,
+                116,
+                117,
+                118,
+                120,
+                122,
+                125,
+                128,
+                129,
+                151,
+                155,
+                156,
+                157,
+                158,
+                160,
+                161,
+                162,
+                164,
+                165,
+                167,
+                170,
+                172,
+                173,
+                174,
+                175,
+                176,
+                177,
+                178,
+                179,
+                182,
+                183,
+                184,
+                185,
+                186,
+                187,
+                188,
+                189,
+                191,
+                192,
+                193,
+                202
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\reporting\\tabular.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                6,
+                7,
+                10,
+                11,
+                22,
+                23,
+                84,
+                85
+            ],
+            "summary": {
+                "covered_lines": 12,
+                "num_statements": 64,
+                "percent_covered": 18.75,
+                "percent_covered_display": "19",
+                "missing_lines": 52,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                8,
+                12,
+                13,
+                16,
+                17,
+                20,
+                25,
+                26,
+                27,
+                30,
+                31,
+                32,
+                35,
+                37,
+                39,
+                40,
+                41,
+                44,
+                45,
+                46,
+                47,
+                48,
+                51,
+                54,
+                56,
+                59,
+                61,
+                82,
+                86,
+                87,
+                88,
+                89,
+                91,
+                92,
+                93,
+                95,
+                96,
+                98,
+                101,
+                103,
+                104,
+                105,
+                106,
+                107,
+                108,
+                109,
+                110,
+                111,
+                120,
+                121,
+                122,
+                131
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\reporting\\text.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                7,
+                9,
+                12,
+                13,
+                16,
+                17,
+                79,
+                80
+            ],
+            "summary": {
+                "covered_lines": 13,
+                "num_statements": 65,
+                "percent_covered": 20.0,
+                "percent_covered_display": "20",
+                "missing_lines": 52,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                10,
+                14,
+                19,
+                20,
+                21,
+                24,
+                25,
+                26,
+                29,
+                31,
+                33,
+                34,
+                35,
+                37,
+                38,
+                40,
+                41,
+                43,
+                44,
+                45,
+                47,
+                49,
+                50,
+                51,
+                53,
+                55,
+                56,
+                77,
+                81,
+                82,
+                83,
+                84,
+                86,
+                87,
+                88,
+                90,
+                91,
+                93,
+                96,
+                98,
+                99,
+                100,
+                101,
+                102,
+                103,
+                104,
+                105,
+                106,
+                115,
+                116,
+                117,
+                127
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\__init__.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6
+            ],
+            "summary": {
+                "covered_lines": 6,
+                "num_statements": 6,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\cart_pole\\DCPW.py": {
+            "executed_lines": [
+                3,
+                4,
+                5,
+                6,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                21,
+                22,
+                23,
+                24,
+                25,
+                26,
+                27,
+                30,
+                31,
+                32,
+                35,
+                37,
+                40,
+                44,
+                47,
+                51,
+                53,
+                74,
+                82,
+                83,
+                85,
+                97,
+                116,
+                121,
+                155,
+                168,
+                172,
+                186,
+                229,
+                274,
+                321,
+                372,
+                377
+            ],
+            "summary": {
+                "covered_lines": 50,
+                "num_statements": 245,
+                "percent_covered": 20.408163265306122,
+                "percent_covered_display": "20",
+                "missing_lines": 195,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                38,
+                42,
+                45,
+                48,
+                54,
+                55,
+                56,
+                57,
+                58,
+                59,
+                60,
+                64,
+                65,
+                67,
+                68,
+                69,
+                70,
+                75,
+                76,
+                77,
+                78,
+                79,
+                86,
+                87,
+                89,
+                90,
+                91,
+                93,
+                94,
+                95,
+                98,
+                102,
+                103,
+                104,
+                105,
+                106,
+                107,
+                108,
+                110,
+                111,
+                112,
+                113,
+                114,
+                117,
+                118,
+                119,
+                125,
+                126,
+                127,
+                128,
+                129,
+                130,
+                131,
+                132,
+                133,
+                135,
+                136,
+                137,
+                138,
+                139,
+                140,
+                141,
+                142,
+                144,
+                147,
+                150,
+                151,
+                153,
+                156,
+                157,
+                158,
+                159,
+                160,
+                164,
+                166,
+                169,
+                170,
+                173,
+                174,
+                175,
+                176,
+                177,
+                178,
+                179,
+                181,
+                182,
+                183,
+                184,
+                187,
+                188,
+                189,
+                193,
+                197,
+                198,
+                199,
+                200,
+                201,
+                206,
+                213,
+                214,
+                216,
+                219,
+                220,
+                223,
+                224,
+                225,
+                226,
+                227,
+                231,
+                232,
+                234,
+                235,
+                236,
+                237,
+                238,
+                239,
+                240,
+                245,
+                247,
+                249,
+                250,
+                253,
+                254,
+                255,
+                257,
+                258,
+                259,
+                260,
+                261,
+                262,
+                265,
+                266,
+                267,
+                269,
+                270,
+                272,
+                275,
+                277,
+                278,
+                280,
+                281,
+                282,
+                283,
+                284,
+                286,
+                288,
+                290,
+                293,
+                294,
+                295,
+                297,
+                299,
+                302,
+                303,
+                305,
+                307,
+                310,
+                311,
+                313,
+                314,
+                319,
+                322,
+                323,
+                324,
+                326,
+                327,
+                328,
+                329,
+                330,
+                332,
+                333,
+                334,
+                337,
+                338,
+                339,
+                340,
+                342,
+                345,
+                348,
+                351,
+                352,
+                353,
+                355,
+                357,
+                358,
+                359,
+                360,
+                361,
+                362,
+                363,
+                365,
+                367,
+                373,
+                374,
+                378
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\cart_pole\\__init__.py": {
+            "executed_lines": [
+                1,
+                2
+            ],
+            "summary": {
+                "covered_lines": 2,
+                "num_statements": 2,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\cart_pole\\cart_pole.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                8,
+                9,
+                11,
+                14,
+                15,
+                18,
+                19,
+                20,
+                21,
+                22,
+                24,
+                25,
+                26,
+                27,
+                28,
+                30,
+                31,
+                33,
+                34,
+                36,
+                73,
+                82
+            ],
+            "summary": {
+                "covered_lines": 28,
+                "num_statements": 66,
+                "percent_covered": 42.42424242424242,
+                "percent_covered_display": "42",
+                "missing_lines": 38,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                41,
+                42,
+                43,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                53,
+                54,
+                55,
+                56,
+                58,
+                59,
+                60,
+                62,
+                63,
+                64,
+                65,
+                66,
+                68,
+                69,
+                70,
+                71,
+                74,
+                76,
+                77,
+                79,
+                80,
+                84,
+                85,
+                86,
+                87,
+                88,
+                89,
+                90
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\cart_pole\\cart_pole_initstate.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                6,
+                7,
+                8,
+                9,
+                11,
+                13,
+                14,
+                17,
+                18,
+                21,
+                22,
+                23,
+                24,
+                25,
+                27,
+                28,
+                29,
+                30,
+                31,
+                32,
+                33,
+                34,
+                35,
+                37,
+                64,
+                76
+            ],
+            "summary": {
+                "covered_lines": 30,
+                "num_statements": 66,
+                "percent_covered": 45.45454545454545,
+                "percent_covered_display": "45",
+                "missing_lines": 36,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                52,
+                53,
+                55,
+                56,
+                57,
+                58,
+                60,
+                61,
+                62,
+                65,
+                66,
+                67,
+                69,
+                70,
+                72,
+                73,
+                74,
+                78,
+                79,
+                80,
+                81,
+                82,
+                83
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\creditfraud.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                5,
+                8,
+                9,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                22,
+                23,
+                24,
+                25,
+                26,
+                28,
+                29,
+                31,
+                33,
+                35,
+                36
+            ],
+            "summary": {
+                "covered_lines": 24,
+                "num_statements": 24,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\digits_keras.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                5,
+                6,
+                9,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                21,
+                22,
+                26,
+                27,
+                29,
+                30,
+                32,
+                82,
+                83,
+                84,
+                85
+            ],
+            "summary": {
+                "covered_lines": 26,
+                "num_statements": 69,
+                "percent_covered": 37.68115942028985,
+                "percent_covered_display": "38",
+                "missing_lines": 43,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                23,
+                24,
+                34,
+                35,
+                36,
+                38,
+                39,
+                40,
+                41,
+                42,
+                43,
+                44,
+                45,
+                46,
+                47,
+                49,
+                51,
+                52,
+                53,
+                54,
+                55,
+                56,
+                57,
+                58,
+                59,
+                60,
+                61,
+                62,
+                63,
+                64,
+                66,
+                67,
+                68,
+                69,
+                70,
+                72,
+                73,
+                74,
+                75,
+                77,
+                78,
+                79,
+                80
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\digits_mlp.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                19,
+                20,
+                21,
+                23,
+                25,
+                27,
+                29,
+                30,
+                32
+            ],
+            "summary": {
+                "covered_lines": 22,
+                "num_statements": 22,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\movie_reviews.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5,
+                6,
+                7,
+                8,
+                10,
+                12,
+                13,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                25,
+                33,
+                40,
+                51,
+                69,
+                88,
+                96,
+                120,
+                121,
+                124,
+                149,
+                181
+            ],
+            "summary": {
+                "covered_lines": 29,
+                "num_statements": 93,
+                "percent_covered": 31.182795698924732,
+                "percent_covered_display": "31",
+                "missing_lines": 64,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                28,
+                29,
+                30,
+                31,
+                37,
+                38,
+                47,
+                48,
+                49,
+                61,
+                63,
+                65,
+                67,
+                76,
+                77,
+                78,
+                79,
+                80,
+                81,
+                83,
+                85,
+                86,
+                90,
+                91,
+                92,
+                93,
+                94,
+                105,
+                106,
+                107,
+                109,
+                110,
+                111,
+                112,
+                113,
+                114,
+                115,
+                116,
+                117,
+                118,
+                128,
+                130,
+                131,
+                132,
+                134,
+                135,
+                136,
+                139,
+                142,
+                146,
+                147,
+                159,
+                162,
+                163,
+                165,
+                168,
+                169,
+                172,
+                175,
+                177,
+                179,
+                183,
+                184,
+                187
+            ],
+            "excluded_lines": []
+        },
+        "counterfit\\targets\\satellite.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                9,
+                12,
+                13,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                24,
+                27,
+                28,
+                29,
+                31,
+                34,
+                36,
+                37,
+                39,
+                40,
+                41,
+                46,
+                50,
+                51,
+                52,
+                54,
+                57,
+                59,
+                63,
+                65,
+                67,
+                73,
+                74,
+                76,
+                77,
+                79,
+                80,
+                82,
+                84
+            ],
+            "summary": {
+                "covered_lines": 46,
+                "num_statements": 46,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\attacks\\art\\test_blackbox_rule_based.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                6,
+                7,
+                8,
+                9,
+                11,
+                13,
+                15,
+                16,
+                17,
+                20,
+                21,
+                22,
+                25,
+                26,
+                27,
+                28,
+                31,
+                32,
+                33,
+                35,
+                36,
+                37,
+                38,
+                39
+            ],
+            "summary": {
+                "covered_lines": 27,
+                "num_statements": 27,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\attacks\\art\\test_hop_skip_jump.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                6,
+                8,
+                9,
+                10,
+                11,
+                13,
+                14,
+                15,
+                16,
+                18,
+                21,
+                22,
+                23,
+                26,
+                27,
+                28,
+                31,
+                32,
+                33,
+                35,
+                36,
+                39,
+                40,
+                42,
+                43
+            ],
+            "summary": {
+                "covered_lines": 28,
+                "num_statements": 29,
+                "percent_covered": 96.55172413793103,
+                "percent_covered_display": "97",
+                "missing_lines": 1,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                37
+            ],
+            "excluded_lines": []
+        },
+        "tests\\attacks\\art\\test_label_only_boundary_distance.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                6,
+                7,
+                8,
+                9,
+                11,
+                12,
+                13,
+                14,
+                17,
+                18,
+                19,
+                22,
+                23,
+                24,
+                27,
+                28,
+                29,
+                31,
+                32,
+                35,
+                36,
+                38,
+                39
+            ],
+            "summary": {
+                "covered_lines": 26,
+                "num_statements": 27,
+                "percent_covered": 96.29629629629629,
+                "percent_covered_display": "96",
+                "missing_lines": 1,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                33
+            ],
+            "excluded_lines": []
+        },
+        "tests\\attacks\\art\\test_mi_face.py": {
+            "executed_lines": [
+                1,
+                2,
+                4,
+                6,
+                7,
+                8,
+                9,
+                11,
+                13,
+                16,
+                17,
+                18,
+                21,
+                22,
+                23,
+                26,
+                27,
+                28,
+                30,
+                31,
+                33,
+                35,
+                37,
+                38
+            ],
+            "summary": {
+                "covered_lines": 24,
+                "num_statements": 25,
+                "percent_covered": 96.0,
+                "percent_covered_display": "96",
+                "missing_lines": 1,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                32
+            ],
+            "excluded_lines": []
+        },
+        "tests\\attacks\\augly\\test_blur.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                6,
+                8,
+                9,
+                10,
+                13,
+                14,
+                15,
+                18,
+                19,
+                20,
+                23,
+                24,
+                25,
+                27,
+                29,
+                31
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 20,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\counterfit\\core\\test_core.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5,
+                6,
+                8,
+                9,
+                11,
+                14,
+                15,
+                16,
+                18,
+                19,
+                29,
+                32,
+                33,
+                44,
+                49
+            ],
+            "summary": {
+                "covered_lines": 18,
+                "num_statements": 19,
+                "percent_covered": 94.73684210526316,
+                "percent_covered_display": "95",
+                "missing_lines": 1,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                12
+            ],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\__init__.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                5,
+                6,
+                7
+            ],
+            "summary": {
+                "covered_lines": 6,
+                "num_statements": 6,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\creditfraud.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5,
+                7,
+                8,
+                10,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                19,
+                20,
+                21,
+                22,
+                23,
+                25,
+                26,
+                29,
+                31,
+                33,
+                34
+            ],
+            "summary": {
+                "covered_lines": 24,
+                "num_statements": 24,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\digits_keras.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                6,
+                9,
+                11,
+                12,
+                13,
+                14,
+                15,
+                16,
+                17,
+                18,
+                19,
+                21,
+                22,
+                26,
+                28,
+                30,
+                31,
+                33,
+                126,
+                127,
+                128,
+                129
+            ],
+            "summary": {
+                "covered_lines": 26,
+                "num_statements": 69,
+                "percent_covered": 37.68115942028985,
+                "percent_covered_display": "38",
+                "missing_lines": 43,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                23,
+                24,
+                35,
+                37,
+                38,
+                41,
+                42,
+                44,
+                45,
+                46,
+                47,
+                48,
+                49,
+                50,
+                51,
+                54,
+                57,
+                59,
+                60,
+                61,
+                62,
+                69,
+                76,
+                77,
+                78,
+                79,
+                84,
+                85,
+                90,
+                91,
+                98,
+                99,
+                100,
+                101,
+                107,
+                110,
+                115,
+                116,
+                117,
+                120,
+                121,
+                122,
+                124
+            ],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\digits_mlp.py": {
+            "executed_lines": [
+                1,
+                3,
+                4,
+                7,
+                8,
+                9,
+                10,
+                11,
+                12,
+                13,
+                14,
+                16,
+                17,
+                18,
+                20,
+                23,
+                25,
+                26,
+                27,
+                29
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 20,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\movie_reviews.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                5,
+                6,
+                7,
+                8,
+                10,
+                12,
+                13,
+                15,
+                16,
+                17,
+                18,
+                19,
+                20,
+                22,
+                23,
+                24,
+                26,
+                35,
+                42,
+                53,
+                71,
+                90,
+                98,
+                122,
+                123,
+                126,
+                151,
+                183
+            ],
+            "summary": {
+                "covered_lines": 29,
+                "num_statements": 94,
+                "percent_covered": 30.851063829787233,
+                "percent_covered_display": "31",
+                "missing_lines": 65,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                29,
+                30,
+                31,
+                32,
+                33,
+                39,
+                40,
+                49,
+                50,
+                51,
+                63,
+                65,
+                67,
+                69,
+                78,
+                79,
+                80,
+                81,
+                82,
+                83,
+                85,
+                87,
+                88,
+                92,
+                93,
+                94,
+                95,
+                96,
+                107,
+                108,
+                109,
+                111,
+                112,
+                113,
+                114,
+                115,
+                116,
+                117,
+                118,
+                119,
+                120,
+                130,
+                132,
+                133,
+                134,
+                136,
+                137,
+                138,
+                141,
+                144,
+                148,
+                149,
+                161,
+                164,
+                165,
+                167,
+                170,
+                171,
+                174,
+                177,
+                179,
+                181,
+                185,
+                186,
+                189
+            ],
+            "excluded_lines": []
+        },
+        "tests\\mocks\\targets\\satellite.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                6,
+                7,
+                9,
+                12,
+                13,
+                16,
+                17,
+                18,
+                19,
+                20,
+                21,
+                22,
+                23,
+                25,
+                27,
+                31,
+                38,
+                41,
+                54,
+                67
+            ],
+            "summary": {
+                "covered_lines": 24,
+                "num_statements": 48,
+                "percent_covered": 50.0,
+                "percent_covered_display": "50",
+                "missing_lines": 24,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                28,
+                29,
+                32,
+                34,
+                36,
+                39,
+                42,
+                43,
+                46,
+                50,
+                51,
+                52,
+                57,
+                59,
+                63,
+                65,
+                70,
+                71,
+                73,
+                74,
+                76,
+                77,
+                78,
+                79
+            ],
+            "excluded_lines": []
+        },
+        "tests\\utils\\__init__.py": {
+            "executed_lines": [
+                1
+            ],
+            "summary": {
+                "covered_lines": 0,
+                "num_statements": 0,
+                "percent_covered": 100.0,
+                "percent_covered_display": "100",
+                "missing_lines": 0,
+                "excluded_lines": 0
+            },
+            "missing_lines": [],
+            "excluded_lines": []
+        },
+        "tests\\utils\\helpers.py": {
+            "executed_lines": [
+                1,
+                2,
+                3,
+                4,
+                5,
+                7,
+                17,
+                19,
+                20,
+                21,
+                24,
+                26,
+                27,
+                28,
+                33,
+                37,
+                38,
+                42,
+                43,
+                45
+            ],
+            "summary": {
+                "covered_lines": 20,
+                "num_statements": 24,
+                "percent_covered": 83.33333333333333,
+                "percent_covered_display": "83",
+                "missing_lines": 4,
+                "excluded_lines": 0
+            },
+            "missing_lines": [
+                9,
+                15,
+                39,
+                41
+            ],
+            "excluded_lines": []
+        }
+    },
+    "totals": {
+        "covered_lines": 1141,
+        "num_statements": 2229,
+        "percent_covered": 51.188873934499775,
+        "percent_covered_display": "51",
+        "missing_lines": 1088,
+        "excluded_lines": 0
+    }
+}
\ No newline at end of file