path: root/tests/java_app/src/android/aidl/tests/TestServiceClient.java

/*
 * Copyright (C) 2015, 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.aidl.tests;

import android.aidl.tests.SimpleParcelable;
import android.aidl.tests.TestFailException;
import android.aidl.tests.TestLogger;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.ServiceSpecificException;
import android.os.Bundle;
import android.os.IBinder;
import android.os.PersistableBundle;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.util.Log;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

// Generated
import android.aidl.tests.INamedCallback;
import android.aidl.tests.ITestService;

public class TestServiceClient extends Activity {
    private static final String TAG = "TestServiceClient";

    private TestLogger mLog;
    private String mSuccessSentinel;
    private String mFailureSentinel;

    private void init() {
        Intent intent = getIntent();
        mLog = new TestLogger(this);
        mLog.log("Reading sentinels from intent...");
        mSuccessSentinel = intent.getStringExtra("sentinel.success");
        mFailureSentinel = intent.getStringExtra("sentinel.failure");
        if (mSuccessSentinel == null || mFailureSentinel == null) {
            String message = "Failed to read intent extra input.";
            Log.e(TAG, message);
            mLog.close();
            throw new RuntimeException(message);
        }
    }

    private ITestService getService() throws TestFailException {
        IBinder service = new ServiceManager().getService(
                ITestService.class.getName());
        if (service == null) {
            mLog.logAndThrow("Failed to obtain binder...");
        }
        ITestService ret = ITestService.Stub.asInterface(service);
        if (ret == null) {
            mLog.logAndThrow("Failed to cast IBinder instance.");
        }
        return ret;
    }

    private void checkPrimitiveRepeat(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can repeat primitives back...");
        try {
            {
                boolean query = true;
                boolean response = service.RepeatBoolean(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                char query = 'A';
                char response = service.RepeatChar(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                byte query = -128;
                byte response = service.RepeatByte(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                int query = 1 << 30;
                int response = service.RepeatInt(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                int query[] = {ITestService.TEST_CONSTANT,
                               ITestService.TEST_CONSTANT2,
                               ITestService.TEST_CONSTANT3,
                               ITestService.TEST_CONSTANT4,
                               ITestService.TEST_CONSTANT5,
                               ITestService.TEST_CONSTANT6,
                               ITestService.TEST_CONSTANT7,
                               ITestService.TEST_CONSTANT8};
                for (int i = 0; i < query.length; i++) {
                    int response = service.RepeatInt(query[i]);
                    if (query[i] != response) {
                        mLog.logAndThrow("Repeat with " + query[i] +
                                " responded " + response);
                    }
                }
            }
            {
                long query = 1L << 60;
                long response = service.RepeatLong(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                float query = 1.0f/3.0f;
                float response = service.RepeatFloat(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                double query = 1.0/3.0;
                double response = service.RepeatDouble(query);
                if (query != response) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }
            {
                Map<String, Object> query = new HashMap<String, Object>();
                query.put("first_val", new Byte((byte)-128));
                query.put("second_val", new Integer(1<<30));
                query.put("third_val", "OHAI");
                Object response = service.RepeatMap(query);
                if (!query.equals(response)) {
                    mLog.logAndThrow("Repeat with " + query +
                                     " responded " + response);
                }
            }

            List<String> queries = Arrays.asList(
                "not empty", "", "\0",
                ITestService.STRING_TEST_CONSTANT,
                ITestService.STRING_TEST_CONSTANT2);
            for (String query : queries) {
                String response = service.RepeatString(query);
                if (!query.equals(response)) {
                    mLog.logAndThrow("Repeat request with '" + query + "'" +
                                     " of length " + query.length() +
                                     " responded with '" + response + "'" +
                                     " of length " + response.length());
                }
            }
        } catch (RemoteException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to repeat a primitive back.");
        }
        mLog.log("...Basic primitive repeating works.");
    }

    private void checkArrayReversal(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can reverse and return arrays...");
        try {
            {
                boolean[] input = {true, false, false, false};
                boolean echoed[] = new boolean[input.length];
                boolean[] reversed = service.ReverseBoolean(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                byte[] input = {0, 1, 2};
                byte echoed[] = new byte[input.length];
                byte[] reversed = service.ReverseByte(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                char[] input = {'A', 'B', 'C', 'D', 'E'};
                char echoed[] = new char[input.length];
                char[] reversed = service.ReverseChar(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                int[] input = {-1, 0, 1, 2, 3, 4, 5, 6};
                int echoed[] = new int[input.length];
                int[] reversed = service.ReverseInt(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                long[] input = {-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8};
                long echoed[] = new long[input.length];
                long[] reversed = service.ReverseLong(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                float[] input = {0.0f, 1.0f, -0.3f};
                float echoed[] = new float[input.length];
                float[] reversed = service.ReverseFloat(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                double[] input = {-1.0, -4.0, -2.0};
                double echoed[] = new double[input.length];
                double[] reversed = service.ReverseDouble(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (input[i] != reversed[j]) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
            {
                String[] input = {"For", "relaxing", "times"};
                String echoed[] = new String[input.length];
                String[] reversed = service.ReverseString(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (!input[i].equals(reversed[j])) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
        } catch (RemoteException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to reverse an array.");
        }
        mLog.log("...service can reverse and return arrays.");
    }

    private void checkBinderExchange(
                ITestService service) throws TestFailException {
      mLog.log("Checking exchange of binders...");
      try {
          INamedCallback got = service.GetOtherTestService("Smythe");
          mLog.log("Received test service");
          String name = got.GetName();

          if (!name.equals("Smythe")) {
              mLog.logAndThrow("Tried to get service with name 'Smythe'" +
                               " and found service with name '" + name + "'");
          }

          if (!service.VerifyName(got, "Smythe")) {
              mLog.logAndThrow("Test service could not verify name of 'Smythe'");
          }
      } catch (RemoteException ex) {
          mLog.log(ex.toString());
          mLog.logAndThrow("Service failed to exchange binders.");
      }
      mLog.log("...Exchange of binders works");
    }

    private void checkListReversal(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can reverse and return lists...");
        try {
            {
                List<String> input = Arrays.asList("Walk", "into", "Córdoba");
                List<String> echoed = new ArrayList<String>();
                List<String> reversed = service.ReverseStringList(input, echoed);
                if (!input.equals(echoed)) {
                    mLog.logAndThrow("Failed to echo input List<String> back.");
                }
                Collections.reverse(input);
                if (!input.equals(reversed)) {
                    mLog.logAndThrow("Reversed list is not correct.");
                }
            }
        } catch (RemoteException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to reverse an List<String>.");
        }
        mLog.log("...service can reverse and return lists.");
    }

    private void checkSimpleParcelables(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can repeat and reverse SimpleParcelable objects...");
        try {
            {
                SimpleParcelable input = new SimpleParcelable("foo", 42);
                SimpleParcelable out_param = new SimpleParcelable();
                SimpleParcelable returned =
                        service.RepeatSimpleParcelable(input, out_param);
                if (!input.equals(out_param)) {
                    mLog.log(input.toString() + " != " + out_param.toString());
                    mLog.logAndThrow("out param SimpleParcelable was not equivalent");
                }
                if (!input.equals(returned)) {
                    mLog.log(input.toString() + " != " + returned.toString());
                    mLog.logAndThrow("returned SimpleParcelable was not equivalent");
                }
            }
            {
                SimpleParcelable[] input = new SimpleParcelable[3];
                input[0] = new SimpleParcelable("a", 1);
                input[1] = new SimpleParcelable("b", 2);
                input[2] = new SimpleParcelable("c", 3);
                SimpleParcelable[] repeated = new SimpleParcelable[3];
                SimpleParcelable[] reversed = service.ReverseSimpleParcelables(
                        input, repeated);
                if (!Arrays.equals(input, repeated)) {
                    mLog.logAndThrow(
                            "Repeated list of SimpleParcelable objects did not match.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow(
                            "Reversed list of SimpleParcelable objects had wrong length.");
                }
                for (int i = 0, k = input.length - 1;
                     i < input.length;
                     ++i, --k) {
                    if (!input[i].equals(reversed[k])) {
                        mLog.log(input[i].toString() + " != " +
                                 reversed[k].toString());
                        mLog.logAndThrow("reversed SimpleParcelable was not equivalent");
                    }
                }
            }
        } catch (Exception ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to handle SimpleParcelable objects.");
        }
        mLog.log("...service can manipulate SimpleParcelable objects.");
    }

    private void checkPersistableBundles(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can repeat and reverse PersistableBundle objects...");
        try {
            {
                PersistableBundle emptyBundle = new PersistableBundle();
                PersistableBundle returned = service.RepeatPersistableBundle(emptyBundle);
                if (emptyBundle.size() != 0 || returned.size() != 0) {
                    mLog.log(emptyBundle.toString() + " != " + returned.toString());
                    mLog.logAndThrow("returned empty PersistableBundle object was not equivalent");
                }
                mLog.log("...service can repeat and reverse empty PersistableBundle objects...");
            }
            {
                final String testBoolKey = new String("testBool");
                final String testIntKey = new String("testInt");
                final String testNestedIntKey = new String("testNestedInt");
                final String testLongKey = new String("testLong");
                final String testDoubleKey = new String("testDouble");
                final String testStringKey = new String("testString");
                final String testBoolArrayKey = new String("testBoolArray");
                final String testIntArrayKey = new String("testIntArray");
                final String testLongArrayKey = new String("testLongArray");
                final String testDoubleArrayKey = new String("testDoubleArray");
                final String testStringArrayKey = new String("testStringArray");
                final String testPersistableBundleKey = new String("testPersistableBundle");
                PersistableBundle nonEmptyBundle = new PersistableBundle();
                nonEmptyBundle.putBoolean(testBoolKey, false);
                nonEmptyBundle.putInt(testIntKey, 33);
                nonEmptyBundle.putLong(testLongKey, 34359738368L);
                nonEmptyBundle.putDouble(testDoubleKey, 1.1);
                nonEmptyBundle.putString(testStringKey, new String("Woot!"));
                nonEmptyBundle.putBooleanArray(testBoolArrayKey, new boolean[] {true, false, true});
                nonEmptyBundle.putIntArray(testIntArrayKey, new int[] {33, 44, 55, 142});
                nonEmptyBundle.putLongArray(
                    testLongArrayKey, new long[] {34L, 8371L, 34359738375L});
                nonEmptyBundle.putDoubleArray(testDoubleArrayKey, new double[] {2.2, 5.4});
                nonEmptyBundle.putStringArray(testStringArrayKey, new String[] {"hello", "world!"});
                PersistableBundle testNestedPersistableBundle = new PersistableBundle();
                testNestedPersistableBundle.putInt(testNestedIntKey, 345);
                nonEmptyBundle.putPersistableBundle(
                    testPersistableBundleKey, testNestedPersistableBundle);
                PersistableBundle returned = service.RepeatPersistableBundle(nonEmptyBundle);
                if (returned.size() != nonEmptyBundle.size()
                    || returned.getBoolean(testBoolKey) != nonEmptyBundle.getBoolean(testBoolKey)
                    || returned.getInt(testIntKey) != nonEmptyBundle.getInt(testIntKey)
                    || returned.getLong(testLongKey) != nonEmptyBundle.getLong(testLongKey)
                    || returned.getDouble(testDoubleKey) != nonEmptyBundle.getDouble(testDoubleKey)
                    || !returned.getString(testStringKey)
                                .equals(nonEmptyBundle.getString(testStringKey))
                    || !Arrays.equals(nonEmptyBundle.getBooleanArray(testBoolArrayKey),
                                      returned.getBooleanArray(testBoolArrayKey))
                    || !Arrays.equals(nonEmptyBundle.getIntArray(testIntArrayKey),
                                      returned.getIntArray(testIntArrayKey))
                    || !Arrays.equals(nonEmptyBundle.getLongArray(testLongArrayKey),
                                      returned.getLongArray(testLongArrayKey))
                    || !Arrays.equals(nonEmptyBundle.getDoubleArray(testDoubleArrayKey),
                                      returned.getDoubleArray(testDoubleArrayKey))
                    || !Arrays.equals(nonEmptyBundle.getStringArray(testStringArrayKey),
                                      returned.getStringArray(testStringArrayKey))) {
                    PersistableBundle temp =
                        returned.getPersistableBundle(testPersistableBundleKey);
                    if (temp == null
                        || temp.getInt(testNestedIntKey)
                            != testNestedPersistableBundle.getInt(testNestedIntKey)) {
                        mLog.log(nonEmptyBundle.toString() + " != " + returned.toString());
                        mLog.logAndThrow("returned non-empty PersistableBundle " +
                                         "object was not equivalent");
                    }
                }
                mLog.log("...service can repeat and reverse non-empty " +
                         "PersistableBundle objects...");
            }
            {
                PersistableBundle[] input = new PersistableBundle[3];
                PersistableBundle first = new PersistableBundle();
                PersistableBundle second = new PersistableBundle();
                PersistableBundle third = new PersistableBundle();
                final String testIntKey = new String("testInt");
                final String testLongKey = new String("testLong");
                final String testDoubleKey = new String("testDouble");
                first.putInt(testIntKey, 1231);
                second.putLong(testLongKey, 222222L);
                third.putDouble(testDoubleKey, 10.8);
                input[0] = first;
                input[1] = second;
                input[2] = third;
                final int original_input_size = input.length;
                PersistableBundle[] repeated = new PersistableBundle[input.length];
                PersistableBundle[] reversed = service.ReversePersistableBundles(input, repeated);
                if (input.length != repeated.length || input.length != original_input_size) {
                    mLog.logAndThrow("Repeated list of PersistableBundle objects had " +
                                     "wrong length.");
                }
                if (input[0].getInt(testIntKey) != repeated[0].getInt(testIntKey)
                    || input[1].getLong(testLongKey) != repeated[1].getLong(testLongKey)
                    || input[2].getDouble(testDoubleKey) != repeated[2].getDouble(testDoubleKey)) {
                    mLog.logAndThrow("Repeated list of PersistableBundle objects did not match.");
                }
                if (input.length != reversed.length || input.length != original_input_size) {
                    mLog.logAndThrow("Reversed list of PersistableBundle objects had " +
                                     "wrong length.");
                }
                if (input[0].getInt(testIntKey) != reversed[2].getInt(testIntKey)
                    || input[1].getLong(testLongKey) != reversed[1].getLong(testLongKey)
                    || input[2].getDouble(testDoubleKey) != reversed[0].getDouble(testDoubleKey)) {
                    mLog.logAndThrow("reversed PersistableBundle objects were not equivalent");
                }
                mLog.log("...service can repeat and reverse arrays of " +
                         "non-empty PersistableBundle objects...");
            }
        } catch (Exception ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to handle PersistableBundle objects.");
        }
        mLog.log("...service can manipulate PersistableBundle objects.");
    }

    private void checkFileDescriptorPassing(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can receive and return file descriptors...");
        try {
            FileOutputStream fileOutputStream =
                    openFileOutput("test-dummy", Context.MODE_PRIVATE);

            FileDescriptor descriptor = fileOutputStream.getFD();
            FileDescriptor journeyed = service.RepeatFileDescriptor(descriptor);
            fileOutputStream.close();

            FileOutputStream journeyedStream = new FileOutputStream(journeyed);

            String testData = "FrazzleSnazzleFlimFlamFlibbityGumboChops";
            byte[] output = testData.getBytes();
            journeyedStream.write(output);
            journeyedStream.close();

            FileInputStream fileInputStream = openFileInput("test-dummy");
            byte[] input = new byte[output.length];
            if (fileInputStream.read(input) != input.length) {
                mLog.logAndThrow("Read short count from file");
            }

            if (!Arrays.equals(input, output)) {
                mLog.logAndThrow("Read incorrect data");
            }
        } catch (RemoteException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to repeat a file descriptor.");
        } catch (IOException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Exception while operating on temporary file");
        }
        mLog.log("...service can receive and return file descriptors.");
    }

    private void checkServiceSpecificExceptions(
                ITestService service) throws TestFailException {
        mLog.log("Checking application exceptions...");
        for (int i = -1; i < 2; ++i) {
            try {
                service.ThrowServiceException(i);
            } catch (RemoteException ex) {
                mLog.logAndThrow("Service threw RemoteException: " +
                                 ex.toString());
            } catch (ServiceSpecificException ex) {
                if (ex.errorCode != i) {
                    mLog.logAndThrow("Service threw wrong error code: " + i);
                }
            }
        }
        mLog.log("...application exceptions work");
    }

    private void checkUtf8Strings(ITestService service)
            throws TestFailException {
        mLog.log("Checking that service can work with UTF8 strings...");
        // Note that Java's underlying encoding is UTF16.
        final List<String> utf8_queries = Arrays.asList(
              "typical string",
              "",
              "\0\0\0",
              // Java doesn't handle unicode code points above U+FFFF well.
              new String(Character.toChars(0x1F701)) + "\u03A9");
        try {
            for (String query : utf8_queries) {
                String response = service.RepeatUtf8CppString(query);
                if (!query.equals(response)) {
                    mLog.logAndThrow("Repeat request with '" + query + "'" +
                                     " of length " + query.length() +
                                     " responded with '" + response + "'" +
                                     " of length " + response.length());
                }
            }
            {
                String[] input = (String[])utf8_queries.toArray();
                String echoed[] = new String[input.length];
                String[] reversed = service.ReverseUtf8CppString(input, echoed);
                if (!Arrays.equals(input, echoed)) {
                    mLog.logAndThrow("Failed to echo utf8 input array back.");
                }
                if (input.length != reversed.length) {
                    mLog.logAndThrow("Reversed utf8 array is the wrong size.");
                }
                for (int i = 0; i < input.length; ++i) {
                    int j = reversed.length - (1 + i);
                    if (!input[i].equals(reversed[j])) {
                        mLog.logAndThrow(
                                "input[" + i + "] = " + input[i] +
                                " but reversed value = " + reversed[j]);
                    }
                }
            }
        } catch (RemoteException ex) {
            mLog.log(ex.toString());
            mLog.logAndThrow("Service failed to handle utf8 strings.");
        }
        mLog.log("...UTF8 annotations work.");
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.i(TAG, "Starting!");
        try {
          init();
          ITestService service = getService();
          checkPrimitiveRepeat(service);
          checkArrayReversal(service);
          checkBinderExchange(service);
          checkListReversal(service);
          checkSimpleParcelables(service);
          checkPersistableBundles(service);
          checkFileDescriptorPassing(service);
          checkServiceSpecificExceptions(service);
          checkUtf8Strings(service);
          new NullableTests(service, mLog).runTests();

          mLog.log(mSuccessSentinel);
        } catch (TestFailException e) {
            mLog.log(mFailureSentinel);
            throw new RuntimeException(e);
        } finally {
            if (mLog != null) {
                mLog.close();
            }
        }
    }
}