qemu.tests:add negative case for balloon test

qemu.tests.balloon_check:
1.Optimize minimum ballooned size for windows guest
2.Optimize illegal test for windows guest
3.Seperate illegal as an individual cfg file
4.Compare windows guest's used memory for balloon check.
5.add function get_used_mem
6.modify the log info

qemu.tests.balloon_service:
1.Optimize code for balloon_service test.

qemu.tests.cfg.balloon_illegal:
1.add new cfg "balloon_illegal.cfg".
2.Adjust code for balloon_illegal test
3.Optimize code for windows's minimum balloon size

qemu.tests.cfg.balloon_service:
1.Set ratio to 0.1

qemu.tests.cfg.balloon_check:
1.Set ratio to 0.1
Signed-off-by: NAihua Liang <aliang@redhat.com>

qemu/tests/balloon_check.py

+import time
 import re
 import logging
 import random
@@ -16,7 +17,7 @@ class BallooningTest(MemoryBaseTest):
 
     def __init__(self, test, params, env):
         self.test_round = 0
-        self.ratio = float(params.get("ratio", 0.5))
+        self.ratio = float(params.get("ratio", 0.1))
         super(BallooningTest, self).__init__(test, params, env)
 
         self.vm = env.get_vm(params["main_vm"])
@@ -61,8 +62,9 @@ class BallooningTest(MemoryBaseTest):
         error.context("Check memory status %s" % step, logging.info)
         mmem = self.get_ballooned_memory()
         gmem = self.get_memory_status()
+        guest_ballooned_mem = abs(gmem - self.ori_gmem)
         if (abs(mmem - self.ori_mem) != ballooned_mem or
-                (abs(gmem - self.ori_gmem) < self.ratio * ballooned_mem)):
+                (abs(guest_ballooned_mem - ballooned_mem) > 100)):
             self.error_report(step, self.ori_mem - ballooned_mem, mmem, gmem)
             raise error.TestFail("Balloon test failed %s" % step)
         return (mmem, gmem)
@@ -77,8 +79,22 @@ class BallooningTest(MemoryBaseTest):
         :type new_mem: int
         """
         error.context("Change VM memory to %s" % new_mem, logging.info)
-        compare_mem = new_mem
-        self.vm.balloon(new_mem)
+        try:
+            self.vm.balloon(new_mem)
+        except Exception, e:
+            if self.params.get('illegal_value_check', 'no') == 'no' and new_mem != self.get_ballooned_memory():
+                raise error.TestFail("Balloon memory fail with error message: %s" % e)
+        if new_mem > self.ori_mem:
+            compare_mem = self.ori_mem
+        elif new_mem == 0:
+            compare_mem = self.current_mmem
+        elif new_mem <= 100:
+            time.sleep(60)
+            self.current_mmem = self.get_ballooned_memory()
+            compare_mem = self.current_mmem
+        else:
+            compare_mem = new_mem
+
         balloon_timeout = float(self.params.get("balloon_timeout", 100))
         status = utils_misc.wait_for((lambda: compare_mem ==
                                       self.get_ballooned_memory()),
@@ -119,7 +135,7 @@ class BallooningTest(MemoryBaseTest):
             qemu_quit_after_test = 0
         return qemu_quit_after_test
 
-    def get_memory_boundary(self, balloon_type='evict'):
+    def get_memory_boundary(self, balloon_type=''):
         """
         Get the legal memory boundary for balloon operation.
 
@@ -131,15 +147,23 @@ class BallooningTest(MemoryBaseTest):
         max_size = self.ori_mem
         min_size = self.params.get("minmem", "512M")
         min_size = int(float(utils_misc.normalize_data_size(min_size)))
-        if balloon_type == 'enlarge':
-            min_size = self.current_mmem
+        if self.params.get('os_type') == 'windows':
+            logging.info("Get windows miminum balloon value:")
+            self.vm.balloon(1)
+            time.sleep(90)
+            used_size = int(self.get_ballooned_memory() + self.ratio * self.ori_mem)
+            self.vm.balloon(max_size)
+            time.sleep(90)
+            self.ori_gmem = self.get_memory_status()
         else:
             vm_total = self.get_memory_status()
             vm_mem_free = self.get_free_mem()
-            # leave 16M buffer to ensure os keep working when do
-            # evict balloon device.
             used_size = vm_total - vm_mem_free + 16
-            min_size = max(used_size, min_size)
+        if balloon_type == "enlarge":
+            min_size = self.current_mmem
+        elif balloon_type == "evict":
+            max_size = self.current_mmem
+        min_size = max(used_size, min_size)
         return min_size, max_size
 
     @error.context_aware
@@ -165,24 +189,14 @@ class BallooningTest(MemoryBaseTest):
             self.memory_check("before ballooning test", 0)
 
         params_tag = self.params.object_params(tag)
-        balloon_type = params_tag.get("balloon_type")
-        min_size, max_size = self.get_memory_boundary(balloon_type)
-
-        if expect_mem < min_size or expect_mem > max_size:
-            raise error.TestError("Memory is set to an illegal size %s. It "
-                                  "should between %s and %s" % (expect_mem,
-                                                                min_size,
-                                                                max_size))
         self.balloon_memory(expect_mem)
         self.test_round += 1
-        if expect_mem > self.current_mmem:
-            balloon_type = "enlarge"
-        elif expect_mem < self.current_mmem:
-            balloon_type = "evict"
-        else:
-            balloon_type = "command test"
-        mmem, gmem = self.memory_check("after %s memory" % balloon_type,
-                                       self.ori_mem - expect_mem)
+        ballooned_memory = self.ori_mem - expect_mem
+        if ballooned_memory < 0 or ballooned_memory == self.ori_mem:
+            ballooned_memory = 0
+        elif ballooned_memory >= self.ori_mem - 100:
+            ballooned_memory = self.ori_mem - self.current_mmem
+        mmem, gmem = self.memory_check("after %s memory" % tag, ballooned_memory)
         self.current_mmem = mmem
         self.current_gmem = gmem
         if (params_tag.get("run_sub_test_after_balloon", "no") == "yes" and
@@ -220,6 +234,12 @@ class BallooningTest(MemoryBaseTest):
         """
         return self.get_guest_free_mem(self.vm)
 
+    def get_used_mem(self):
+        """
+        Report used memory detect by OS.
+        """
+        return self.get_guest_used_mem(self.vm)
+
     def get_total_mem(self):
         """
         Report total memory detect by OS.
@@ -277,10 +297,10 @@ class BallooningTestWin(BallooningTest):
         """
         Get Memory status inside guest.
 
-        :return: the free memory size inside guest.
+        :return: the used memory size inside guest.
         :rtype: int
         """
-        return int(self.get_free_mem())
+        return int(self.get_used_mem())
 
 
 class BallooningTestLinux(BallooningTest):
@@ -332,6 +352,8 @@ def run(test, params, env):
         balloon_test = BallooningTestWin(test, params, env)
     else:
         balloon_test = BallooningTestLinux(test, params, env)
+        logging.info("Waiting 90s for guest's applications up")
+        time.sleep(90)
 
     for tag in params.objects('test_tags'):
         error.context("Running %s test" % tag, logging.info)
@@ -341,10 +363,18 @@ def run(test, params, env):
         elif params_tag.get('expect_memory_ratio'):
             expect_mem = int(balloon_test.ori_mem *
                              float(params_tag.get('expect_memory_ratio')))
+        elif tag == 'evict' and params_tag.get('illegal_value_check', 'no') == 'yes' and params['os_type'] == 'windows':
+            expect_mem = int(random.uniform(0, 100))
         else:
             balloon_type = params_tag['balloon_type']
             min_sz, max_sz = balloon_test.get_memory_boundary(balloon_type)
-            expect_mem = int(random.uniform(min_sz, max_sz))
+            if params_tag.get('illegal_value_check', 'no') == 'yes':
+                if tag == 'enlarge':
+                    expect_mem = int((max_sz)+random.uniform(1, 1000))
+                else:
+                    expect_mem = 0
+            else:
+                expect_mem = int(random.uniform(min_sz, max_sz))
 
         quit_after_test = balloon_test.run_ballooning_test(expect_mem, tag)
         if quit_after_test:

qemu/tests/balloon_service.py

@@ -91,7 +91,7 @@ def run(test, params, env):
 
         error_context.context("Compare memory from guest with qmp",
                               logging.info)
-        if (abs(guest_mem - stat_memory_qmp)) > (guest_mem * check_mem_ratio):
+        if (abs(guest_mem - stat_memory_qmp) / guest_mem) > check_mem_ratio:
             raise exceptions.TestFail("%s of guest %s is not equal to %s in"
                                       " qmp, the acceptable ratio is %s" %
                                       (keyname, guest_mem, stat_memory_qmp,
@@ -107,24 +107,28 @@ def run(test, params, env):
         repeat_times = int(params.get("repeat_times", 5))
         logging.info("repeat times: %d" % repeat_times)
         balloon_test = BallooningTestWin(test, params, env)
-
+        balloon_test = BallooningTestWin(test, params, env)
+        min_sz, max_sz = balloon_test.get_memory_boundary()
         while repeat_times:
             for tag in params.objects('test_tags'):
                 error_context.context("Running %s test" % tag, logging.info)
                 params_tag = params.object_params(tag)
                 balloon_type = params_tag['balloon_type']
-                min_sz, max_sz = balloon_test.get_memory_boundary(balloon_type)
-                expect_mem = int(random.uniform(min_sz, max_sz))
+                if balloon_type == 'evict':
+                    expect_mem = int(random.uniform(min_sz, balloon_test.get_ballooned_memory()))
+                else:
+                    expect_mem = int(random.uniform(balloon_test.get_ballooned_memory(), max_sz))
 
                 quit_after_test = balloon_test.run_ballooning_test(expect_mem,
                                                                    tag)
+                time.sleep(20)
                 get_polling_output = vm.monitor.qom_get(device_path,
                                                         get_balloon_property)
+                time.sleep(20)
                 memory_check(vm, get_polling_output, 'stat-free-memory')
                 if quit_after_test:
                     return
 
-            balloon_test.reset_memory()
             repeat_times -= 1
 
     timeout = int(params.get("login_timeout", 360))

qemu/tests/cfg/balloon_illegal.cfg

+- balloon_illegal:
+    virt_test_type = qemu
+    no Win2000, Fedora.8, Fedora.9, Fedora.10, RHEL.3, RHEL.4, Unix, livecd
+    type = balloon_check
+    balloon = balloon0
+    balloon_dev_devid = balloon0
+    balloon_dev_add_bus = yes
+    free_mem_cmd = cat /proc/meminfo | grep MemFree
+    Linux:
+        ratio = 1
+    Windows:
+        ratio = 0.5
+    illegal_value_check = yes
+    test_tags = "evict enlarge"
+    balloon_type_evict = evict
+    balloon_type_enlarge = enlarge

qemu/tests/cfg/balloon_service.cfg

@@ -25,7 +25,7 @@
     polling_interval = 2
     polling_sleep_time = 10
     free_mem_cmd = wmic os get FreePhysicalMemory
-    ratio = 0.5
+    ratio = 0.1
     run_sub_test_after_balloon = no
     test_tags = "evict enlarge"
     balloon_type_evict = evict