os/cts/WorkSourceTest.java

/*
 * Copyright (C) 2013 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.os.cts;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import java.util.Arrays;

import android.os.WorkSource;
import android.test.AndroidTestCase;

public class WorkSourceTest extends AndroidTestCase {
    private Constructor<WorkSource> mConstructWS;
    private Object[] mConstructWSArgs = new Object[1];
    private Method mAddUid;
    private Object[] mAddUidArgs = new Object[1];
    private Method mAddUidName;
    private Object[] mAddUidNameArgs = new Object[2];
    private Method mAddReturningNewbs;
    private Object[] mAddReturningNewbsArgs = new Object[1];
    private Method mSetReturningDiffs;
    private Object[] mSetReturningDiffsArgs = new Object[1];

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        mConstructWS = WorkSource.class.getConstructor(new Class[] { int.class });
        mAddUid = WorkSource.class.getMethod("add", new Class[] { int.class });
        mAddUidName = WorkSource.class.getMethod("add", new Class[] { int.class, String.class });
        mAddReturningNewbs = WorkSource.class.getMethod("addReturningNewbs", new Class[] { WorkSource.class });
        mSetReturningDiffs = WorkSource.class.getMethod("setReturningDiffs", new Class[] { WorkSource.class });
    }

    private WorkSource wsNew(int uid) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        mConstructWSArgs[0] = uid;
        return mConstructWS.newInstance(mConstructWSArgs);
    }

    private WorkSource wsNew(int[] uids) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        WorkSource ws = new WorkSource();
        for (int i=0; i<uids.length; i++) {
            wsAdd(ws, uids[i]);
        }
        checkWorkSource("Constructed", ws, uids);
        return ws;
    }

    private WorkSource wsNew(int[] uids, String[] names) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        WorkSource ws = new WorkSource();
        for (int i=0; i<uids.length; i++) {
            wsAdd(ws, uids[i], names[i]);
        }
        checkWorkSource("Constructed", ws, uids, names);
        return ws;
    }

    private boolean wsAdd(WorkSource ws, int uid) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        mAddUidArgs[0] = uid;
        return (Boolean)mAddUid.invoke(ws, mAddUidArgs);
    }

    private boolean wsAdd(WorkSource ws, int uid, String name) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        mAddUidNameArgs[0] = uid;
        mAddUidNameArgs[1] = name;
        return (Boolean)mAddUidName.invoke(ws, mAddUidNameArgs);
    }

    private WorkSource wsAddReturningNewbs(WorkSource ws, WorkSource other) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        mAddReturningNewbsArgs[0] = other;
        return (WorkSource)mAddReturningNewbs.invoke(ws, mAddReturningNewbsArgs);
    }

    private WorkSource[] wsSetReturningDiffs(WorkSource ws, WorkSource other) throws IllegalArgumentException,
            InstantiationException, IllegalAccessException, InvocationTargetException {
        mSetReturningDiffsArgs[0] = other;
        return (WorkSource[])mSetReturningDiffs.invoke(ws, mSetReturningDiffsArgs);
    }

    private void printArrays(StringBuilder sb, int[] uids, String[] names) {
        sb.append("{ ");
        for (int i=0; i<uids.length; i++) {
            if (i > 0) sb.append(", ");
            sb.append(uids[i]);
            if (names != null) {
                sb.append(" ");
                sb.append(names[i]);
            }
        }
        sb.append(" }");
    }

    private void failWorkSource(String op, WorkSource ws, int[] uids) {
        StringBuilder sb = new StringBuilder();
        sb.append(op);
        sb.append(": Expected: ");
        printArrays(sb, uids, null);
        sb.append(", got: ");
        sb.append(ws);
        fail(sb.toString());
    }

    private void failWorkSource(String op, WorkSource ws, int[] uids, String[] names) {
        StringBuilder sb = new StringBuilder();
        sb.append(op);
        sb.append(": Expected: ");
        printArrays(sb, uids, names);
        sb.append(", got: ");
        sb.append(ws);
        fail(sb.toString());
    }

    private void checkWorkSource(String op, WorkSource ws, int[] uids) {
        if (ws == null || uids == null) {
            if (ws != null) {
                fail(op + ": WorkSource is not null " + ws +", but expected null");
            }
            if (uids != null) {
                fail(op + "WorkSource is null, but expected non-null: " + Arrays.toString(uids));
            }
            return;
        }
        if (ws.size() != uids.length) {
            failWorkSource(op, ws, uids);
        }
        for (int i=0; i<uids.length; i++) {
            if (uids[i] != ws.get(i)) {
                failWorkSource(op, ws, uids);
            }
        }
    }

    private void checkWorkSource(String op, WorkSource ws, int[] uids, String[] names) {
        if (ws == null || uids == null) {
            if (ws != null) {
                fail(op + ": WorkSource is not null " + ws +", but expected null");
            }
            if (uids != null) {
                fail(op + "WorkSource is null, but expected non-null: " + Arrays.toString(uids));
            }
            return;
        }
        if (ws.size() != uids.length) {
            failWorkSource(op, ws, uids, names);
        }
        for (int i=0; i<uids.length; i++) {
            if (uids[i] != ws.get(i) || !names[i].equals(ws.getName(i))) {
                failWorkSource(op, ws, uids, names);
            }
        }
    }

    public void testConstructEmpty() {
        checkWorkSource("Empty", new WorkSource(), new int[] { });
    }

    public void testConstructSingle() throws Exception {
        checkWorkSource("Single 1", wsNew(1), new int[] { 1 });
    }

    public void testAddRawOrdered() throws Exception {
        WorkSource ws = wsNew(1);
        wsAdd(ws, 2);
        checkWorkSource("First", ws, new int[] { 1 , 2 });
        wsAdd(ws, 20);
        checkWorkSource("Second", ws, new int[] { 1 , 2, 20 });
        wsAdd(ws, 100);
        checkWorkSource("Third", ws, new int[] { 1, 2, 20, 100 });
    }

    public void testAddRawRevOrdered() throws Exception {
        WorkSource ws = wsNew(100);
        wsAdd(ws, 20);
        checkWorkSource("First", ws, new int[] { 20, 100 });
        wsAdd(ws, 2);
        checkWorkSource("Second", ws, new int[] { 2, 20, 100 });
        wsAdd(ws, 1);
        checkWorkSource("Third", ws, new int[] { 1, 2, 20, 100 });
    }

    public void testAddRawUnordered() throws Exception {
        WorkSource ws = wsNew(10);
        wsAdd(ws, 2);
        checkWorkSource("First", ws, new int[] { 2, 10 });
        wsAdd(ws, 5);
        checkWorkSource("Second", ws, new int[] { 2, 5, 10 });
        wsAdd(ws, 1);
        checkWorkSource("Third", ws, new int[] { 1, 2, 5, 10 });
        wsAdd(ws, 100);
        checkWorkSource("Fourth", ws, new int[] { 1, 2, 5, 10, 100 });
    }

    public void testAddWsOrdered() throws Exception {
        WorkSource ws = wsNew(1);
        ws.add(wsNew(2));
        checkWorkSource("First", ws, new int[] { 1 , 2 });
        ws.add(wsNew(20));
        checkWorkSource("Second", ws, new int[] { 1 , 2, 20 });
        ws.add(wsNew(100));
        checkWorkSource("Third", ws, new int[] { 1 , 2, 20, 100 });
    }

    public void testAddWsRevOrdered() throws Exception {
        WorkSource ws = wsNew(100);
        ws.add(wsNew(20));
        checkWorkSource("First", ws, new int[] { 20, 100 });
        ws.add(wsNew(2));
        checkWorkSource("Second", ws, new int[] { 2, 20, 100 });
        ws.add(wsNew(1));
        checkWorkSource("Third", ws, new int[] { 1, 2, 20, 100 });
    }

    public void testAddWsUnordered() throws Exception {
        WorkSource ws = wsNew(10);
        ws.add(wsNew(2));
        checkWorkSource("First", ws, new int[] { 2, 10 });
        ws.add(wsNew(5));
        checkWorkSource("Second", ws, new int[] { 2, 5, 10 });
        ws.add(wsNew(1));
        checkWorkSource("Third", ws, new int[] { 1, 2, 5, 10 });
        ws.add(wsNew(100));
        checkWorkSource("Fourth", ws, new int[] { 1, 2, 5, 10, 100 });
    }

    private void doTestCombineTwoUids(int[] lhs, int[] rhs, int[] expected, int[] newbs,
            int[] gones) throws Exception {
        WorkSource ws1 = wsNew(lhs);
        WorkSource ws2 = wsNew(rhs);
        ws1.add(ws2);
        checkWorkSource("Add result", ws1, expected);
        ws1 = wsNew(lhs);
        WorkSource wsNewbs = wsAddReturningNewbs(ws1, ws2);
        checkWorkSource("AddReturning result", ws1, expected);
        checkWorkSource("Newbs", wsNewbs, newbs);
        ws1 = wsNew(lhs);
        WorkSource[] res = wsSetReturningDiffs(ws1, ws2);
        checkWorkSource("SetReturning result", ws1, rhs);
        checkWorkSource("Newbs", res[0], newbs);
        checkWorkSource("Gones", res[1], gones);
    }

    private int[] makeRepeatingIntArray(String[] stringarray, int value) {
        if (stringarray == null) {
            return null;
        }
        int[] res = new int[stringarray.length];
        for (int i=0; i<stringarray.length; i++) {
            res[i] = value;
        }
        return res;
    }

    private void doTestCombineTwoNames(String[] lhsnames, String[] rhsnames,
            String[] expectednames, String[] newbnames,
            String[] gonenames) throws Exception {
        int[] lhs = makeRepeatingIntArray(lhsnames, 0);
        int[] rhs = makeRepeatingIntArray(rhsnames, 0);
        int[] expected = makeRepeatingIntArray(expectednames, 0);
        int[] newbs = makeRepeatingIntArray(newbnames, 0);
        int[] gones = makeRepeatingIntArray(gonenames, 0);
        doTestCombineTwoUidsNames(lhs, lhsnames, rhs, rhsnames, expected, expectednames,
                newbs, newbnames, gones, gonenames);
    }

    private void doTestCombineTwoUidsNames(int[] lhs, String[] lhsnames, int[] rhs, String[] rhsnames,
            int[] expected, String[] expectednames, int[] newbs, String[] newbnames,
            int[] gones, String[] gonenames) throws Exception {
        WorkSource ws1 = wsNew(lhs, lhsnames);
        WorkSource ws2 = wsNew(rhs, rhsnames);
        ws1.add(ws2);
        checkWorkSource("Add result", ws1, expected, expectednames);
        ws1 = wsNew(lhs, lhsnames);
        WorkSource wsNewbs = wsAddReturningNewbs(ws1, ws2);
        checkWorkSource("AddReturning result", ws1, expected, expectednames);
        checkWorkSource("Newbs", wsNewbs, newbs, newbnames);
        ws1 = wsNew(lhs, lhsnames);
        WorkSource[] res = wsSetReturningDiffs(ws1, ws2);
        checkWorkSource("SetReturning result", ws1, rhs, rhsnames);
        checkWorkSource("Newbs", res[0], newbs, newbnames);
        checkWorkSource("Gones", res[1], gones, gonenames);
    }

    private String[] makeRepeatingStringArray(int[] intarray, String value) {
        if (intarray == null) {
            return null;
        }
        String[] res = new String[intarray.length];
        for (int i=0; i<intarray.length; i++) {
            res[i] = value;
        }
        return res;
    }

    private String[] makeStringArray(int[] intarray) {
        if (intarray == null) {
            return null;
        }
        String[] res = new String[intarray.length];
        for (int i=0; i<intarray.length; i++) {
            res[i] = Character.toString((char)('A' + intarray[i]));
        }
        return res;
    }

    private void doTestCombineTwo(int[] lhs, int[] rhs, int[] expected, int[] newbs,
            int[] gones) throws Exception {
        doTestCombineTwoUids(lhs, rhs, expected, newbs, gones);
        doTestCombineTwoUidsNames(lhs, makeRepeatingStringArray(lhs, "A"),
                rhs, makeRepeatingStringArray(rhs, "A"),
                expected, makeRepeatingStringArray(expected, "A"),
                newbs, makeRepeatingStringArray(newbs, "A"),
                gones, makeRepeatingStringArray(gones, "A"));
        doTestCombineTwoNames(makeStringArray(lhs), makeStringArray(rhs),
                makeStringArray(expected), makeStringArray(newbs), makeStringArray(gones));
    }

    public void testCombineMultiFront() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 2, 15, 16 },
                new int[] { 1, 2, 10, 15, 16, 20, 30, 40 },
                new int[] { 1, 2, 15, 16 },
                new int[] { 10, 20, 30, 40 });
    }

    public void testCombineMultiMiddle() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 12, 14, 22 },
                new int[] { 10, 12, 14, 20, 22, 30, 40 },
                new int[] { 12, 14, 22 },
                new int[] { 10, 20, 30, 40 });
    }

    public void testCombineMultiEnd() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 35, 45, 50 },
                new int[] { 10, 20, 30, 35, 40, 45, 50 },
                new int[] { 35, 45, 50 },
                new int[] { 10, 20, 30, 40 });
    }

    public void testCombineMultiFull() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 2, 15, 35, 50 },
                new int[] { 1, 2, 10, 15, 20, 30, 35, 40, 50 },
                new int[] { 1, 2, 15, 35, 50 },
                new int[] { 10, 20, 30, 40 });
    }

    public void testCombineMultiSame() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 10, 20, 30 },
                new int[] { 10, 20, 30, 40 },
                null,
                new int[] { 40 });
    }

    public void testCombineMultiSomeSame() throws Exception {
        doTestCombineTwo(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 30, 40 },
                new int[] { 1, 10, 20, 30, 40 },
                new int[] { 1 },
                new int[] { 10, 20 });
    }

    public void testCombineMultiSomeSameUidsNames() throws Exception {
        doTestCombineTwoUidsNames(
                new int[]    { 10,  10,  20,  30,  30,  30,  40 },
                new String[] { "A", "B", "A", "A", "B", "C", "A" },
                new int[]    { 1,   30,  40,  50 },
                new String[] { "A", "A", "B", "A" },
                new int[]    { 1,   10,  10,  20,  30,  30,  30,  40,  40,  50 },
                new String[] { "A", "A", "B", "A", "A", "B", "C", "A", "B", "A" },
                new int[]    { 1,   40,  50 },
                new String[] { "A", "B", "A" },
                new int[]    { 10,  10,  20,  30,  30,  40 },
                new String[] { "A", "B", "A", "B", "C", "A" });
    }

    private void doTestRemoveUids(int[] lhs, int[] rhs, int[] result, boolean diff) throws Exception {
        WorkSource ws1 = wsNew(lhs);
        WorkSource ws2 = wsNew(rhs);
        boolean diffres = ws1.remove(ws2);
        if (diffres != diff) {
            StringBuilder sb = new StringBuilder();
            sb.append("Expected diff ");
            sb.append(diff);
            sb.append(" but got ");
            sb.append(diffres);
            sb.append(" when removing ");
            sb.append(ws2);
            sb.append(" from ");
            sb.append(ws1);
            fail(sb.toString());
        }
        checkWorkSource("Remove", ws1, result);
    }

    private void doTestRemoveNames(String[] lhsnames, String[] rhsnames,
            String[] resultnames, boolean diff) throws Exception {
        int[] lhs = makeRepeatingIntArray(lhsnames, 0);
        int[] rhs = makeRepeatingIntArray(rhsnames, 0);
        int[] result = makeRepeatingIntArray(resultnames, 0);
        WorkSource ws1 = wsNew(lhs, lhsnames);
        WorkSource ws2 = wsNew(rhs, rhsnames);
        boolean diffres = ws1.remove(ws2);
        if (diffres != diff) {
            StringBuilder sb = new StringBuilder();
            sb.append("Expected diff ");
            sb.append(diff);
            sb.append(" but got ");
            sb.append(diffres);
            sb.append(" when removing ");
            sb.append(ws2);
            sb.append(" from ");
            sb.append(ws1);
            fail(sb.toString());
        }
        checkWorkSource("Remove", ws1, result, resultnames);
    }

    private void doTestRemoveUidsNames(int[] lhs, String[] lhsnames, int[] rhs, String[] rhsnames,
            int[] result, String[] resultnames, boolean diff) throws Exception {
        WorkSource ws1 = wsNew(lhs, lhsnames);
        WorkSource ws2 = wsNew(rhs, rhsnames);
        boolean diffres = ws1.remove(ws2);
        if (diffres != diff) {
            StringBuilder sb = new StringBuilder();
            sb.append("Expected diff ");
            sb.append(diff);
            sb.append(" but got ");
            sb.append(diffres);
            sb.append(" when removing ");
            sb.append(ws2);
            sb.append(" from ");
            sb.append(ws1);
            fail(sb.toString());
        }
        checkWorkSource("Remove", ws1, result, resultnames);
    }

    private void doTestRemove(int[] lhs, int[] rhs, int[] result, boolean diff) throws Exception {
        doTestRemoveUids(lhs, rhs, result, diff);
        doTestRemoveUidsNames(lhs, makeRepeatingStringArray(lhs, "A"),
                rhs, makeRepeatingStringArray(rhs, "A"),
                result, makeRepeatingStringArray(result, "A"),
                diff);
        doTestRemoveNames(makeStringArray(lhs), makeStringArray(rhs),
                makeStringArray(result), diff);
    }

    public void testRemoveNone() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 2, 35, 50 },
                new int[] { 10, 20, 30, 40 },
                false);
    }

    public void testRemoveMultiFront() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 2, 10, 30 },
                new int[] { 20, 40 },
                true);
    }

    public void testRemoveMultiMiddle() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 20, 30 },
                new int[] { 10, 40 },
                true);
    }

    public void testRemoveMultiEnd() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 30, 40, 50 },
                new int[] { 10, 20 },
                true);
    }

    public void testRemoveMultiFull() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 1, 2, 20, 25, 35, 40 },
                new int[] { 10, 30 },
                true);
    }

    public void testRemoveMultiAll() throws Exception {
        doTestRemove(
                new int[] { 10, 20, 30, 40 },
                new int[] { 10, 20, 30, 40 },
                new int[] { },
                true);
    }
}