Solve test measurements issue with CI (#895)

### Before submitting

Please complete the following checklist when submitting a PR:

- [ ] All new features must include a unit test.
If you've fixed a bug or added code that should be tested, add a test to
the
      [`tests`](../tests) directory!

- [ ] All new functions and code must be clearly commented and
documented.
If you do make documentation changes, make sure that the docs build and
      render correctly by running `make docs`.

- [ ] Ensure that the test suite passes, by running `make test`.

- [ ] Add a new entry to the `.github/CHANGELOG.md` file, summarizing
the
      change, and including a link back to the PR.

- [ ] Ensure that code is properly formatted by running `make format`. 

When all the above are checked, delete everything above the dashed
line and fill in the pull request template.


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

**Context:**
Revert changes about testing the measurements with shots. The
probability of failing the test is non zero then something the test can
fail randomly and reduces the CI quality in all PR.

**Description of the Change:**

**Benefits:**
Stop failing the CI regarding the measurement test with shots

**Possible Drawbacks:**

**Related GitHub Issues:**

---------

Co-authored-by: ringo-but-quantum <[email protected]>
Co-authored-by: Ali Asadi <[email protected]>

Author: 3 people

pennylane_lightning/core/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.39.0-dev9"
+__version__ = "0.39.0-dev10"

tests/lightning_qubit/test_measurements_class.py

@@ -408,8 +408,8 @@ def calculate_reference(tape, lightning_sv):
         m = LightningMeasurements(statevector)
         return m.measure_final_state(tape)
 
-    @flaky(max_runs=15)
-    @pytest.mark.parametrize("shots", [None, 200_000, [190_000, 190_000]])
+    @flaky(max_runs=5)
+    @pytest.mark.parametrize("shots", [None, 500_000, [500_000, 500_000]])
     @pytest.mark.parametrize("measurement", [qml.expval, qml.probs, qml.var])
     @pytest.mark.parametrize(
         "observable",
@@ -449,16 +449,12 @@ def test_single_return_value(self, shots, measurement, observable, lightning_sv,
             pytest.skip(
                 f"Measurement of type {type(measurement).__name__} does not have a keyword argument 'wires'."
             )
-        rtol = 1.0e-2  # 1% of expected value as tolerance
         if shots != None and measurement is qml.expval:
             # Increase the number of shots
             if isinstance(shots, int):
-                shots *= 10
+                shots = 1_000_000
             else:
-                shots = [i * 10 for i in shots]
-
-            # Extra tolerance
-            rtol = 5.0e-2  # 5% of expected value as tolerance
+                shots = [1_000_000, 1_000_000]
 
         n_qubits = 4
         n_layers = 1
@@ -499,14 +495,13 @@ def test_single_return_value(self, shots, measurement, observable, lightning_sv,
         if shots is None:
             assert np.allclose(result, expected, max(tol, 1.0e-4))
         else:
-            atol = max(tol, 1.0e-2) if statevector.dtype == np.complex64 else max(tol, 1.0e-3)
-            rtol = max(tol, rtol)  # % of expected value as tolerance
-
+            # TODO Set better atol and rtol
+            dtol = max(tol, 1.0e-2)
             # allclose -> absolute(a - b) <= (atol + rtol * absolute(b))
-            assert np.allclose(result, expected, rtol=rtol, atol=atol)
+            assert np.allclose(result, expected, rtol=dtol, atol=dtol)
 
-    @flaky(max_runs=10)
-    @pytest.mark.parametrize("shots", [None, 100_000, (90_000, 90_000)])
+    @flaky(max_runs=5)
+    @pytest.mark.parametrize("shots", [None, 400_000, (400_000, 400_000)])
     @pytest.mark.parametrize("measurement", [qml.expval, qml.probs, qml.var])
     @pytest.mark.parametrize(
         "obs0_",
@@ -557,16 +552,12 @@ def test_double_return_value(self, shots, measurement, obs0_, obs1_, lightning_s
                 f"Observable of type {type(obs0_).__name__} is not supported for rotating probabilities."
             )
 
-        rtol = 1.0e-2  # 1% of expected value as tolerance
         if shots != None and measurement is qml.expval:
             # Increase the number of shots
             if isinstance(shots, int):
-                shots *= 10
+                shots = 1_000_000
             else:
-                shots = [i * 10 for i in shots]
-
-            # Extra tolerance
-            rtol = 5.0e-2  # 5% of expected value as tolerance
+                shots = [1_000_000, 1_000_000]
 
         n_qubits = 4
         n_layers = 1
@@ -610,14 +601,14 @@ def test_double_return_value(self, shots, measurement, obs0_, obs1_, lightning_s
         assert isinstance(result, Sequence)
         assert len(result) == len(expected)
         # a few tests may fail in single precision, and hence we increase the tolerance
-        atol = tol if shots is None else max(tol, 1.0e-2)
-        rtol = max(tol, rtol)  # % of expected value as tolerance
+        dtol = tol if shots is None else max(tol, 1.0e-2)
+        # TODO Set better atol and rtol
         for r, e in zip(result, expected):
             if isinstance(shots, tuple) and isinstance(r[0], np.ndarray):
                 r = np.concatenate(r)
                 e = np.concatenate(e)
             # allclose -> absolute(r - e) <= (atol + rtol * absolute(e))
-            assert np.allclose(r, e, atol=atol, rtol=rtol)
+            assert np.allclose(r, e, atol=dtol, rtol=dtol)
 
     @pytest.mark.parametrize(
         "cases",