diff --git a/manifests/crc/BYODB-installation/minikube/kruize-crc-minikube.yaml b/manifests/crc/BYODB-installation/minikube/kruize-crc-minikube.yaml
index 594ff3d4a..f918ded0b 100644
--- a/manifests/crc/BYODB-installation/minikube/kruize-crc-minikube.yaml
+++ b/manifests/crc/BYODB-installation/minikube/kruize-crc-minikube.yaml
@@ -65,7 +65,7 @@ spec:
     spec:
       containers:
         - name: kruize
-          image: kruize/autotune_operator:0.0.20_rm
+          image: kruize/autotune_operator:0.0.20.1_rm
           imagePullPolicy: Always
           volumeMounts:
             - name: config-volume
diff --git a/manifests/crc/BYODB-installation/openshift/kruize-crc-openshift.yaml b/manifests/crc/BYODB-installation/openshift/kruize-crc-openshift.yaml
index 1e05697c6..efe1557b0 100644
--- a/manifests/crc/BYODB-installation/openshift/kruize-crc-openshift.yaml
+++ b/manifests/crc/BYODB-installation/openshift/kruize-crc-openshift.yaml
@@ -65,7 +65,7 @@ spec:
     spec:
       containers:
         - name: kruize
-          image: kruize/autotune_operator:0.0.20_rm
+          image: kruize/autotune_operator:0.0.20.1_rm
           imagePullPolicy: Always
           volumeMounts:
             - name: config-volume
diff --git a/manifests/crc/default-db-included-installation/minikube/kruize-crc-minikube.yaml b/manifests/crc/default-db-included-installation/minikube/kruize-crc-minikube.yaml
index 2963ed20d..9e28c53e0 100644
--- a/manifests/crc/default-db-included-installation/minikube/kruize-crc-minikube.yaml
+++ b/manifests/crc/default-db-included-installation/minikube/kruize-crc-minikube.yaml
@@ -143,7 +143,7 @@ spec:
     spec:
       containers:
         - name: kruize
-          image: kruize/autotune_operator:0.0.20_rm
+          image: kruize/autotune_operator:0.0.20.1_rm
           imagePullPolicy: Always
           volumeMounts:
             - name: config-volume
@@ -208,7 +208,7 @@ spec:
         spec:
           containers:
             - name: kruizecronjob
-              image: kruize/autotune_operator:0.0.20_rm
+              image: kruize/autotune_operator:0.0.20.1_rm
               imagePullPolicy: Always
               volumeMounts:
                 - name: config-volume
diff --git a/manifests/crc/default-db-included-installation/openshift/kruize-crc-openshift.yaml b/manifests/crc/default-db-included-installation/openshift/kruize-crc-openshift.yaml
index 49386b72c..43f235c76 100644
--- a/manifests/crc/default-db-included-installation/openshift/kruize-crc-openshift.yaml
+++ b/manifests/crc/default-db-included-installation/openshift/kruize-crc-openshift.yaml
@@ -189,7 +189,7 @@ spec:
       serviceAccountName: kruize-sa
       containers:
         - name: kruize
-          image: kruize/autotune_operator:0.0.20_rm
+          image: kruize/autotune_operator:0.0.20.1_rm
           imagePullPolicy: Always
           volumeMounts:
             - name: config-volume
@@ -261,7 +261,7 @@ spec:
         spec:
           containers:
             - name: kruizecronjob
-              image: kruize/autotune_operator:0.0.20_rm
+              image: kruize/autotune_operator:0.0.20.1_rm
               imagePullPolicy: Always
               volumeMounts:
                 - name: config-volume
diff --git a/pom.xml b/pom.xml
index 6c909f1c4..11d644b07 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>org.autotune</groupId>
     <artifactId>autotune</artifactId>
-    <version>0.0.20_mvp</version>
+    <version>0.0.20.1_mvp</version>
     <properties>
         <fabric8-version>4.13.0</fabric8-version>
         <org-json-version>20201115</org-json-version>
diff --git a/scripts/kruize_metrics.py b/scripts/kruize_metrics.py
index 8fc1b9ddb..b492d5a54 100644
--- a/scripts/kruize_metrics.py
+++ b/scripts/kruize_metrics.py
@@ -231,7 +231,6 @@ def job(queries_type,outputdir,server,prometheus_url=None):
         writer.writerow(results_map)
 
 def schedule_job(queries_type,server,prometheus_url):
-    outputdir = "results"
     if not os.path.exists(outputdir):
         os.mkdir(outputdir)
     numeric_time = int(time_duration[:-1])
@@ -268,8 +267,9 @@ def main(argv):
     global resultsfile
     global namespace
     global prometheus_url
+    global outputdir
 
-    parser = argparse.ArgumentParser(description='kruize_metrics.py -c <cluster_type> -s <cluster_name> -p <prometheus_url> -t <time duration for a query in mins:Default:60m> -d <duration the script runs in hours> -q <query_type:increase/total.Default:increase> -o <single data point:Default:true>')
+    parser = argparse.ArgumentParser(description='kruize_metrics.py -c <cluster_type> -s <cluster_name> -p <prometheus_url> -t <time duration for a query in mins:Default:60m> -d <duration the script runs in hours> -q <query_type:increase/total.Default:increase> -o <single data point:Default:true> -e <results dir:Default:results')
     parser.add_argument('-c', '--cluster_type', help='Cluster type. Supported types:openshift/minikube')
     parser.add_argument('-s', '--cluster_name', help='Name/IP to access the openshift/minikube cluster. Example:kruize-rm.p1.openshiftapps.com/localhost. Prometheus URL is generated using this name if prometheus_url is None')
     parser.add_argument('-p', '--prometheus_url', help='Prometheus URL',default=None)
@@ -278,6 +278,7 @@ def main(argv):
     parser.add_argument('-q', '--queries_type', help='Query type: increase/total', default='increase')
     parser.add_argument('-o', '--get_one_data_point', help='Single data point', default='true')
     parser.add_argument('-r', '--resultsfile', help='Results file',default='kruizemetrics.csv')
+    parser.add_argument('-e', '--outputdir', help='directory to store the results', default='results')
     #args = parser.parse_args()
     args, unknown = parser.parse_known_args()
 
@@ -300,6 +301,7 @@ def main(argv):
     getOneDataPoint = args.get_one_data_point
     resultsfile = args.resultsfile
     prometheus_url = args.prometheus_url
+    outputdir = args.outputdir
 
     if cluster_type == "openshift":
         namespace = "openshift-tuning"
diff --git a/src/main/java/com/autotune/analyzer/performanceProfiles/utils/PerformanceProfileUtil.java b/src/main/java/com/autotune/analyzer/performanceProfiles/utils/PerformanceProfileUtil.java
index 174a3571f..c40f314d1 100644
--- a/src/main/java/com/autotune/analyzer/performanceProfiles/utils/PerformanceProfileUtil.java
+++ b/src/main/java/com/autotune/analyzer/performanceProfiles/utils/PerformanceProfileUtil.java
@@ -218,6 +218,7 @@ public static String validateMetricsValues(String metricVariableName, MetricResu
                 if (value instanceof String) {
                     stringValue = (String) value;
                 }
+                // TODO: handle the conversions for additional supported formats
                 if (!KruizeSupportedTypes.SUPPORTED_FORMATS.contains(stringValue)) {
                     LOGGER.error(AnalyzerErrorConstants.AutotuneObjectErrors.UNSUPPORTED_FORMAT);
                     errorMsg = errorMsg.concat(AnalyzerErrorConstants.AutotuneObjectErrors.UNSUPPORTED_FORMAT);
diff --git a/src/main/java/com/autotune/utils/KruizeSupportedTypes.java b/src/main/java/com/autotune/utils/KruizeSupportedTypes.java
index fdacd8dbd..28f3181a3 100644
--- a/src/main/java/com/autotune/utils/KruizeSupportedTypes.java
+++ b/src/main/java/com/autotune/utils/KruizeSupportedTypes.java
@@ -78,7 +78,7 @@ private KruizeSupportedTypes() { }
 			new HashSet<>(Arrays.asList("deployment", "pod", "container"));
 	
   public static final Set<String> SUPPORTED_FORMATS =
-			new HashSet<>(Arrays.asList("cores", "MiB"));
+			new HashSet<>(Arrays.asList("cores", "m", "Bytes", "bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "kB", "KB", "MB", "GB", "TB", "PB", "EB", "K", "k", "M", "G", "T", "P", "E"));
 
 	public static final Set<String> QUERY_PARAMS_SUPPORTED = new HashSet<>(Arrays.asList(
 			"experiment_name", "results", "recommendations", "latest"
diff --git a/tests/scripts/remote_monitoring_tests/helpers/utils.py b/tests/scripts/remote_monitoring_tests/helpers/utils.py
index f346e16e6..aad97c4a4 100644
--- a/tests/scripts/remote_monitoring_tests/helpers/utils.py
+++ b/tests/scripts/remote_monitoring_tests/helpers/utils.py
@@ -394,6 +394,14 @@ def validate_container(update_results_container, update_results_json, list_reco_
             interval_end_time = update_results["interval_end_time"]
             interval_start_time = update_results["interval_start_time"]
             print(f"interval_end_time = {interval_end_time} interval_start_time = {interval_start_time}")
+
+            # Obtain the metrics
+            metrics = ""
+            containers = update_results['kubernetes_objects'][0]['containers']
+            for container in containers:
+                if update_results_container["container_image_name"] == container["container_image_name"]:
+                    metrics = container["metrics"]
+
             if check_if_recommendations_are_present(list_reco_container["recommendations"]):
                 terms_obj = list_reco_container["recommendations"]["data"][interval_end_time]["recommendation_terms"]
                 current_config = list_reco_container["recommendations"]["data"][interval_end_time]["current"]
@@ -401,6 +409,7 @@ def validate_container(update_results_container, update_results_json, list_reco_
                 duration_terms = ["short_term", "medium_term", "long_term"]
                 for term in duration_terms:
                     if check_if_recommendations_are_present(terms_obj[term]):
+                        print(f"reco present for term {term}")
                         # Validate timestamps [deprecated as monitoring end time is moved to higher level]
                         # assert cost_obj[term]["monitoring_end_time"] == interval_end_time, \
                         #    f"monitoring end time {cost_obj[term]['monitoring_end_time']} did not match end timestamp {interval_end_time}"
@@ -439,7 +448,7 @@ def validate_container(update_results_container, update_results_json, list_reco_
                             for engine_entry in engines_list:
                                 if engine_entry in terms_obj[term]["recommendation_engines"]:
                                     engine_obj = terms_obj[term]["recommendation_engines"][engine_entry]
-                                    validate_config(engine_obj["config"])
+                                    validate_config(engine_obj["config"], metrics)
                                     validate_variation(current_config, engine_obj["config"], engine_obj["variation"])
 
             else:
@@ -452,17 +461,27 @@ def validate_container(update_results_container, update_results_json, list_reco_
         assert result == False, f"Recommendations notifications does not contain the expected message - {NOT_ENOUGH_DATA_MSG}"
 
 
-def validate_config(reco_config):
+def validate_config(reco_config, metrics):
+    cpu_format_type = ""
+    memory_format_type = ""
+
+    for metric in metrics:
+        if "cpuUsage" == metric["name"]:
+            cpu_format_type = metric['results']['aggregation_info']['format']
+
+        if "memoryUsage" == metric["name"]:
+            memory_format_type = metric['results']['aggregation_info']['format']
+
     usage_list = ["requests", "limits"]
     for usage in usage_list:
         assert reco_config[usage]["cpu"][
                    "amount"] > 0, f"cpu amount in recommendation config is {reco_config[usage]['cpu']['amount']}"
         assert reco_config[usage]["cpu"][
-                   "format"] == "cores", f"cpu format in recommendation config is {reco_config[usage]['cpu']['format']}"
+                   "format"] == cpu_format_type, f"cpu format in recommendation config is {reco_config[usage]['cpu']['format']} instead of {cpu_format_type}"
         assert reco_config[usage]["memory"][
                    "amount"] > 0, f"cpu amount in recommendation config is {reco_config[usage]['memory']['amount']}"
         assert reco_config[usage]["memory"][
-                   "format"] == "MiB", f"memory format in recommendation config is {reco_config[usage]['memory']['format']}"
+                   "format"] == memory_format_type, f"memory format in recommendation config is {reco_config[usage]['memory']['format']} instead of {memory_format_type}"
 
 
 def check_if_recommendations_are_present(cost_obj):
@@ -635,11 +654,13 @@ def validate_variation(current_config: dict, recommended_config: dict, variation
                 current_cpu_value = current_requests[CPU_KEY][AMOUNT_KEY]
             assert variation_requests[CPU_KEY][AMOUNT_KEY] == recommended_requests[CPU_KEY][
                 AMOUNT_KEY] - current_cpu_value
+            assert variation_requests[CPU_KEY][FORMAT_KEY] == recommended_requests[CPU_KEY][FORMAT_KEY]
         if MEMORY_KEY in recommended_requests:
             if MEMORY_KEY in current_requests and AMOUNT_KEY in current_requests[MEMORY_KEY]:
                 current_memory_value = current_requests[MEMORY_KEY][AMOUNT_KEY]
             assert variation_requests[MEMORY_KEY][AMOUNT_KEY] == recommended_requests[MEMORY_KEY][
                 AMOUNT_KEY] - current_memory_value
+            assert variation_requests[MEMORY_KEY][FORMAT_KEY] == recommended_requests[MEMORY_KEY][FORMAT_KEY]
     if recommended_limits is not None:
         current_cpu_value = 0
         current_memory_value = 0
@@ -647,8 +668,10 @@ def validate_variation(current_config: dict, recommended_config: dict, variation
             if CPU_KEY in current_limits and AMOUNT_KEY in current_limits[CPU_KEY]:
                 current_cpu_value = current_limits[CPU_KEY][AMOUNT_KEY]
             assert variation_limits[CPU_KEY][AMOUNT_KEY] == recommended_limits[CPU_KEY][AMOUNT_KEY] - current_cpu_value
+            assert variation_limits[CPU_KEY][FORMAT_KEY] == recommended_limits[CPU_KEY][FORMAT_KEY]
         if MEMORY_KEY in recommended_limits:
             if MEMORY_KEY in current_limits and AMOUNT_KEY in current_limits[MEMORY_KEY]:
                 current_memory_value = current_limits[MEMORY_KEY][AMOUNT_KEY]
             assert variation_limits[MEMORY_KEY][AMOUNT_KEY] == recommended_limits[MEMORY_KEY][
                 AMOUNT_KEY] - current_memory_value
+            assert variation_limits[MEMORY_KEY][FORMAT_KEY] == recommended_limits[MEMORY_KEY][FORMAT_KEY]
diff --git a/tests/scripts/remote_monitoring_tests/rest_apis/test_list_recommendations.py b/tests/scripts/remote_monitoring_tests/rest_apis/test_list_recommendations.py
index 70c8cd6d1..2db22dfd4 100644
--- a/tests/scripts/remote_monitoring_tests/rest_apis/test_list_recommendations.py
+++ b/tests/scripts/remote_monitoring_tests/rest_apis/test_list_recommendations.py
@@ -255,14 +255,23 @@ def test_list_recommendations_single_exp_multiple_results(cluster_type):
     result_json_file = "../json_files/multiple_results_single_exp.json"
     response = update_results(result_json_file)
 
+    # Get the experiment name
+    json_data = json.load(open(input_json_file))
+    experiment_name = json_data[0]['experiment_name']
+    end_time = "2023-04-14T23:59:20.982Z"
+
     data = response.json()
     assert response.status_code == SUCCESS_STATUS_CODE
     assert data['status'] == SUCCESS_STATUS
     assert data['message'] == UPDATE_RESULTS_SUCCESS_MSG
 
-    # Get the experiment name
-    json_data = json.load(open(input_json_file))
-    experiment_name = json_data[0]['experiment_name']
+    response = update_recommendations(experiment_name, None, end_time)
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data[0]['experiment_name'] == experiment_name
+    assert data[0]['kubernetes_objects'][0]['containers'][0]['recommendations']['notifications'][
+            NOTIFICATION_CODE_FOR_RECOMMENDATIONS_AVAILABLE]['message'] == RECOMMENDATIONS_AVAILABLE
+
 
     response = list_recommendations(experiment_name)
 
@@ -276,18 +285,101 @@ def test_list_recommendations_single_exp_multiple_results(cluster_type):
     # Validate the json values
     create_exp_json = read_json_data_from_file(input_json_file)
 
-    # Uncomment the below lines when bulk entries are allowed
-    # update_results_json = read_json_data_from_file(result_json_file)
+    expected_duration_in_hours = SHORT_TERM_DURATION_IN_HRS_MAX
 
-    # Since bulk entries are not supported passing None for update results json
-    update_results_json = None
-    validate_reco_json(create_exp_json[0], update_results_json, list_reco_json[0])
+    update_results_json = []
+    result_json_arr = read_json_data_from_file(result_json_file)
+    update_results_json.append(result_json_arr[len(result_json_arr) - 1])
+    validate_reco_json(create_exp_json[0], update_results_json, list_reco_json[0], expected_duration_in_hours)
 
     # Delete the experiment
     response = delete_experiment(input_json_file)
     print("delete exp = ", response.status_code)
 
 
+@pytest.mark.sanity
+@pytest.mark.parametrize("memory_format_type", ["bytes", "Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "kB", "KB", "MB", "GB", "TB", "PB", "EB", "K", "k", "M", "G", "T", "P", "E"])
+@pytest.mark.parametrize("cpu_format_type", ["cores", "m"])
+
+def test_list_recommendations_supported_metric_formats(memory_format_type, cpu_format_type, cluster_type):
+    """
+    Test Description: This test validates listRecommendations by updating multiple results for a single experiment
+    """
+    input_json_file = "../json_files/create_exp.json"
+
+    form_kruize_url(cluster_type)
+    response = delete_experiment(input_json_file)
+    print("delete exp = ", response.status_code)
+
+    # Create experiment using the specified json
+    response = create_experiment(input_json_file)
+
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data['status'] == SUCCESS_STATUS
+    assert data['message'] == CREATE_EXP_SUCCESS_MSG
+
+    # Update results for the experiment
+    result_json_file = "../json_files/multiple_results_single_exp.json"
+
+
+    # Update the memory format and cpu format
+    result_json = read_json_data_from_file(result_json_file)
+
+    for result in result_json:
+        metrics = result['kubernetes_objects'][0]['containers'][0]['metrics']
+
+        for metric in metrics:
+            if "cpu" in metric['name']:
+                metric['results']['aggregation_info']['format'] = cpu_format_type
+
+            if "memory" in metric['name']:
+                metric['results']['aggregation_info']['format'] = memory_format_type
+
+    tmp_update_results_json_file = "/tmp/update_results_metric" + "_" + memory_format_type + "_" + cpu_format_type + ".json"
+    write_json_data_to_file(tmp_update_results_json_file, result_json)
+
+    # Update the results
+    response = update_results(tmp_update_results_json_file)
+
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data['status'] == SUCCESS_STATUS
+    assert data['message'] == UPDATE_RESULTS_SUCCESS_MSG
+
+    # Get the experiment name
+    json_data = json.load(open(input_json_file))
+    experiment_name = json_data[0]['experiment_name']
+    end_time = "2023-04-14T23:59:20.982Z" 
+
+    response = update_recommendations(experiment_name, None, end_time)
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data[0]['experiment_name'] == experiment_name
+    assert data[0]['kubernetes_objects'][0]['containers'][0]['recommendations']['notifications'][
+            NOTIFICATION_CODE_FOR_RECOMMENDATIONS_AVAILABLE]['message'] == RECOMMENDATIONS_AVAILABLE
+
+    response = list_recommendations(experiment_name)
+
+    list_reco_json = response.json()
+    assert response.status_code == SUCCESS_200_STATUS_CODE
+
+    # Validate the json against the json schema
+    errorMsg = validate_list_reco_json(list_reco_json, list_reco_json_schema)
+    assert errorMsg == ""
+
+    # Validate the json values
+    create_exp_json = read_json_data_from_file(input_json_file)
+
+    expected_duration_in_hours = SHORT_TERM_DURATION_IN_HRS_MAX
+
+    update_results_json = []
+    result_json_arr = read_json_data_from_file(tmp_update_results_json_file)
+    update_results_json.append(result_json_arr[len(result_json_arr) - 1])
+
+    validate_reco_json(create_exp_json[0], update_results_json, list_reco_json[0], expected_duration_in_hours)
+
+
 @pytest.mark.extended
 def test_list_recommendations_multiple_exps_from_diff_json_files_2(cluster_type):
     """
diff --git a/tests/scripts/remote_monitoring_tests/rest_apis/test_update_results.py b/tests/scripts/remote_monitoring_tests/rest_apis/test_update_results.py
index 084fd9c28..e2692534e 100644
--- a/tests/scripts/remote_monitoring_tests/rest_apis/test_update_results.py
+++ b/tests/scripts/remote_monitoring_tests/rest_apis/test_update_results.py
@@ -309,6 +309,126 @@ def test_update_multiple_valid_results_after_create_exp(cluster_type):
     response = delete_experiment(input_json_file)
     print("delete exp = ", response.status_code)
 
+@pytest.mark.sanity
+@pytest.mark.parametrize("format_type", ["cores", "m"])
+def test_update_multiple_valid_results_with_supported_cpu_format_types(format_type, cluster_type):
+    """
+    Test Description: This test validates update results for a valid experiment
+    """
+    input_json_file = "../json_files/create_exp.json"
+
+    form_kruize_url(cluster_type)
+    response = delete_experiment(input_json_file)
+    print("delete exp = ", response.status_code)
+
+    # Create experiment using the specified json
+    response = create_experiment(input_json_file)
+
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data['status'] == SUCCESS_STATUS
+
+    # Update results for the experiment
+    num_res = 96
+    find_start_ts = "2022-01-23T18:25:43.511Z"
+    find_end_ts = "2022-01-23T18:40:43.570Z"
+
+    cpu_format = "cores"
+
+    result_json_file = "../json_files/update_results.json"
+    filename = "/tmp/result.json"
+    for i in range(num_res):
+
+        with open(result_json_file, 'r') as file:
+            data = file.read()
+
+        if i == 0:
+            start_ts = get_datetime()
+        else:
+            start_ts = end_ts
+
+        print("start_ts = ", start_ts)
+        data = data.replace(find_start_ts, start_ts)
+
+        end_ts = increment_timestamp_by_given_mins(start_ts, 15)
+        print("end_ts = ", end_ts)
+        data = data.replace(find_end_ts, end_ts)
+
+        data = data.replace(cpu_format, format_type)
+
+        with open(filename, 'w') as file:
+            file.write(data)
+
+        response = update_results(filename)
+
+        data = response.json()
+        print("message = ", data['message'])
+
+        assert response.status_code == SUCCESS_STATUS_CODE
+        assert data['status'] == SUCCESS_STATUS
+
+@pytest.mark.sanity
+@pytest.mark.parametrize("format_type", ["bytes", "Bytes", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "kB", "KB", "MB", "GB", "TB", "PB", "EB", "K", "k", "M", "G", "T", "P", "E"])
+def test_update_multiple_valid_results_with_supported_mem_format_types(format_type, cluster_type):
+    """
+    Test Description: This test validates update results for a valid experiment
+    """
+    input_json_file = "../json_files/create_exp.json"
+
+    form_kruize_url(cluster_type)
+    response = delete_experiment(input_json_file)
+    print("delete exp = ", response.status_code)
+
+    # Create experiment using the specified json
+    response = create_experiment(input_json_file)
+
+    data = response.json()
+    assert response.status_code == SUCCESS_STATUS_CODE
+    assert data['status'] == SUCCESS_STATUS
+
+    # Update results for the experiment
+    num_res = 96
+    find_start_ts = "2022-01-23T18:25:43.511Z"
+    find_end_ts = "2022-01-23T18:40:43.570Z"
+
+    memory_format = "MiB"
+
+    result_json_file = "../json_files/update_results.json"
+    filename = "/tmp/result.json"
+    for i in range(num_res):
+
+        with open(result_json_file, 'r') as file:
+            data = file.read()
+
+        if i == 0:
+            start_ts = get_datetime()
+        else:
+            start_ts = end_ts
+
+        print("start_ts = ", start_ts)
+        data = data.replace(find_start_ts, start_ts)
+
+        end_ts = increment_timestamp_by_given_mins(start_ts, 15)
+        print("end_ts = ", end_ts)
+        data = data.replace(find_end_ts, end_ts)
+
+        data = data.replace(memory_format, format_type)
+
+        with open(filename, 'w') as file:
+            file.write(data)
+
+        response = update_results(filename)
+
+        data = response.json()
+        print("message = ", data['message'])
+
+        assert response.status_code == SUCCESS_STATUS_CODE
+        assert data['status'] == SUCCESS_STATUS
+        assert data['message'] == UPDATE_RESULTS_SUCCESS_MSG
+
+    response = delete_experiment(input_json_file)
+    print("delete exp = ", response.status_code)
+
 
 @pytest.mark.sanity
 def test_update_results_multiple_exps_from_same_json_file(cluster_type):