gt:                 long used = total - free;
context: /* Copyright Statement:
   *
   * This software/firmware and related documentation ("MediaTek Software") are
   * protected under relevant copyright laws. The information contained herein is
   * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
   * the prior written permission of MediaTek inc. and/or its licensors, any
   * reproduction, modification, use or disclosure of MediaTek Software, and
   * information contained herein, in whole or in part, shall be strictly
   * prohibited.
   * 
   * MediaTek Inc. (C) 2010. All rights reserved.
   * 
   * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
   * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
   * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
   * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
   * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
   * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
   * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
   * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
   * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
   * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
   * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
   * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
   * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
   * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
   * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
   * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
   * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
   * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
   *
   * The following software/firmware and/or related documentation ("MediaTek
   * Software") have been modified by MediaTek Inc. All revisions are subject to
   * any receiver's applicable license agreements with MediaTek Inc.
   */
  
  /*
   * Copyright (C) 2008 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.test;
  
  import com.android.internal.util.Predicate;
  import com.android.internal.util.Predicates;
  
  import dalvik.annotation.BrokenTest;
  import dalvik.annotation.SideEffect;
  
  import android.app.KeyguardManager;
  import android.content.Context;
  import android.content.pm.PackageManager;
  import android.os.Bundle;
  import android.test.suitebuilder.TestMethod;
  import android.test.suitebuilder.annotation.HasAnnotation;
  import android.util.Log;
  
  import java.io.File;
  import java.lang.reflect.Field;
  import java.lang.reflect.Modifier;
  import java.util.List;
  import java.util.TimeZone;
  
  import junit.framework.AssertionFailedError;
  import junit.framework.Test;
  import junit.framework.TestCase;
  import junit.framework.TestListener;
  
  /**
   * This test runner extends the default InstrumentationTestRunner. It overrides
   * the {@code onCreate(Bundle)} method and sets the system properties necessary
   * for many core tests to run. This is needed because there are some core tests
   * that need writing access to the file system. We also need to set the harness
   * Thread's context ClassLoader. Otherwise some classes and resources will not
   * be found. Finally, we add a means to free memory allocated by a TestCase
   * after its execution.
   *
   * @hide
   */
  public class InstrumentationCtsTestRunner extends InstrumentationTestRunner {
  
      /**
       * Convenience definition of our log tag.
       */
      private static final String TAG = "InstrumentationCtsTestRunner";
  
      private static final String REPORT_VALUE_ID = "InstrumentationCtsTestRunner";
  
      /**
       * True if (and only if) we are running in single-test mode (as opposed to
       * batch mode).
       */
      private boolean mSingleTest = false;
  
      @Override
      public void onCreate(Bundle arguments) {
          // We might want to move this to /sdcard, if is is mounted/writable.
          File cacheDir = getTargetContext().getCacheDir();
  
          // Set some properties that the core tests absolutely need.
          System.setProperty("user.language", "en");
          System.setProperty("user.region", "US");
  
          System.setProperty("java.home", cacheDir.getAbsolutePath());
          System.setProperty("user.home", cacheDir.getAbsolutePath());
          System.setProperty("java.io.tmpdir", cacheDir.getAbsolutePath());
          System.setProperty("user.dir", cacheDir.getAbsolutePath());
          System.setProperty("javax.net.ssl.trustStore",
                  "/etc/security/cacerts.bks");
  
          TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
  
          if (arguments != null) {
              String classArg = arguments.getString(ARGUMENT_TEST_CLASS);
              mSingleTest = classArg != null && classArg.contains("#");
          }
  
          // attempt to disable keyguard,  if current test has permission to do so
          // TODO: move this to a better place, such as InstrumentationTestRunner ?
          if (getContext().checkCallingOrSelfPermission(android.Manifest.permission.DISABLE_KEYGUARD)
                  == PackageManager.PERMISSION_GRANTED) {
              Log.i(TAG, "Disabling keyguard");
              KeyguardManager keyguardManager =
                  (KeyguardManager) getContext().getSystemService(Context.KEYGUARD_SERVICE);
              keyguardManager.newKeyguardLock("cts").disableKeyguard();
          } else {
              Log.i(TAG, "Test lacks permission to disable keyguard. " +
                      "UI based tests may fail if keyguard is up");
          }
  
          super.onCreate(arguments);
      }
  
      @Override
      protected AndroidTestRunner getAndroidTestRunner() {
          AndroidTestRunner runner = super.getAndroidTestRunner();
  
          runner.addTestListener(new TestListener() {
              /**
               * The last test class we executed code from.
               */
              private Class<?> lastClass;
  
              /**
               * The minimum time we expect a test to take.
               */
              private static final int MINIMUM_TIME = 100;
  
              /**
               * The start time of our current test in System.currentTimeMillis().
               */
              private long startTime;
  
              public void startTest(Test test) {
                  if (test.getClass() != lastClass) {
                      lastClass = test.getClass();
                      printMemory(test.getClass());
                  }
  
                  Thread.currentThread().setContextClassLoader(
                          test.getClass().getClassLoader());
  
                  startTime = System.currentTimeMillis();
              }
  
              public void endTest(Test test) {
                  if (test instanceof TestCase) {
                      cleanup((TestCase)test);
  
                      /*
                       * Make sure all tests take at least MINIMUM_TIME to
                       * complete. If they don't, we wait a bit. The Cupcake
                       * Binder can't handle too many operations in a very
                       * short time, which causes headache for the CTS.
                       */
                      long timeTaken = System.currentTimeMillis() - startTime;
  
                      if (timeTaken < MINIMUM_TIME) {
                          try {
                              Thread.sleep(MINIMUM_TIME - timeTaken);
                          } catch (InterruptedException ignored) {
                              // We don't care.
                          }
                      }
                  }
              }
  
              public void addError(Test test, Throwable t) {
                  // This space intentionally left blank.
              }
  
              public void addFailure(Test test, AssertionFailedError t) {
                  // This space intentionally left blank.
              }
  
              /**
               * Dumps some memory info.
               */
              private void printMemory(Class<? extends Test> testClass) {
                  Runtime runtime = Runtime.getRuntime();
  
                  long total = runtime.totalMemory();
                  long free = runtime.freeMemory();
  