xref: /frameworks/base/services/tests/servicestests/src/com/android/server/utils/PriorityDumpTest.java

/**
 * Copyright (c) 2016, 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 com.android.server.utils;

import static com.android.server.utils.PriorityDump.dump;

import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertArrayEquals;
import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.same;
import static org.mockito.Mockito.verify;

import android.platform.test.annotations.Presubmit;
import android.support.test.filters.SmallTest;
import com.android.server.utils.PriorityDump.PriorityDumper;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.io.FileDescriptor;
import java.io.PrintWriter;

@SmallTest
@Presubmit
@RunWith(JUnit4.class)
public class PriorityDumpTest {

    private static final String[] EMPTY_ARGS = {};

    @Mock
    private PriorityDumper mDumper;
    @Mock
    private PrintWriter mPw;

    private final FileDescriptor mFd = FileDescriptor.err;

    @Before
    public void setup() {
        MockitoAnnotations.initMocks(this);
    }

    @Test
    public void testNullArgs() {
        dump(mDumper, mFd, mPw, null);
        verify(mDumper).dump(same(mFd), same(mPw), eq(null), /* asProto= */ eq(false));
    }

    @Test
    public void testNoArgs() {
        dump(mDumper, mFd, mPw, EMPTY_ARGS);
        verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
    }

    @Test
    public void testNonPriorityArgs() {
        final String[] args = {
                "--dumb_priority"
        };
        dump(mDumper, mFd, mPw, args);
        verify(mDumper).dump(same(mFd), same(mPw), eq(args), /* asProto= */ eq(false));
    }

    @Test
    public void testMissingPriority() {
        final String[] args = {
                "--dump-priority"
        };
        dump(mDumper, mFd, mPw, args);
        verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
    }

    @Test
    public void testInvalidPriorityNoExtraArgs() {
        final String[] args = {
                "--dump-priority", "SUPER_HIGH"
        };
        dump(mDumper, mFd, mPw, args);
        verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
    }

    @Test
    public void testInvalidPriorityExtraArgs() {
        final String[] args = {
                "--dump-priority", "SUPER_HIGH", "--high", "--five"
        };
        dump(mDumper, mFd, mPw, args);
        verify(mDumper).dump(same(mFd), same(mPw), eq(new String[] {
            "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testNoPriorityCallsAllMethods() {
        final String[] args = {
                "1", "2", "3"
        };

        // Cannot use mDumper here because it would mock the dump() call.
        final FakeDumper fakeDumper = new FakeDumper();

        dump(fakeDumper, mFd, mPw, args);

        assertSame(mFd, fakeDumper.criticalFd);
        assertSame(mPw, fakeDumper.criticalPw);
        assertArrayEquals(args, fakeDumper.criticalArgs);
        assertSame(mFd, fakeDumper.highFd);
        assertSame(mPw, fakeDumper.highPw);
        assertArrayEquals(args, fakeDumper.highArgs);
        assertSame(mFd, fakeDumper.normalFd);
        assertSame(mPw, fakeDumper.normalPw);
        assertArrayEquals(args, fakeDumper.normalArgs);
    }

    @Test
    public void testCriticalNoExtraArgs() {
        dump(mDumper, mFd, mPw, new String[] {
                "--dump-priority", "CRITICAL"
        });
        verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(EMPTY_ARGS),
                /* asProto= */ eq(false));
    }

    @Test
    public void testCriticalExtraArgs() {
        dump(mDumper, mFd, mPw, new String[] {
                "--dump-priority", "CRITICAL", "--high", "--five"
        });
        verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
                "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testCriticalExtraArgsInMiddle() {
        dump(mDumper, mFd, mPw, new String[] {
                "--high", "--dump-priority", "CRITICAL", "--five"
        });
        verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
                "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testCriticalExtraArgsAtEnd() {
        dump(mDumper, mFd, mPw, new String[] {
                "--high", "--five", "--dump-priority", "CRITICAL"
        });
        verify(mDumper).dumpCritical(same(mFd), same(mPw), eq(new String[] {
                "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testHighNoExtraArgs() {
        dump(mDumper, mFd, mPw, new String[] {
                "--dump-priority", "HIGH"
        });
        verify(mDumper).dumpHigh(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
    }

    @Test
    public void testHighExtraArgs() {
        dump(mDumper, mFd, mPw, new String[] {
                "--dump-priority", "HIGH", "--high", "--five"
        });
        verify(mDumper).dumpHigh(same(mFd), same(mPw), eq(new String[] {
                "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testNormalNoExtraArgs() {
        dump(mDumper, mFd, mPw, new String[] {
                "--dump-priority", "NORMAL"
        });
        verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(false));
    }

    @Test
    public void testNormalExtraArgs() {
        dump(mDumper, mFd, mPw, new String[]{
                "--dump-priority", "NORMAL", "--high", "--five"
        });
        verify(mDumper).dumpNormal(same(mFd), same(mPw), eq(new String[]{
                "--high", "--five"
        }), /* asProto= */ eq(false));
    }

    @Test
    public void testProtoArgs() {
        dump(mDumper, mFd, mPw, new String[]{"--proto"});
        verify(mDumper).dump(same(mFd), same(mPw), eq(EMPTY_ARGS), /* asProto= */ eq(true));
    }

    @Test
    public void testProtoArgsWithPriorityArgs() {
        dump(mDumper, mFd, mPw, new String[]{"--proto", "--dump-priority", "NORMAL", "--five"});
        verify(mDumper).dumpNormal(same(mFd), same(mPw),
                eq(new String[]{"--five"}), /* asProto= */ eq(true));
    }

    @Test
    public void testProtoArgsWithPriorityArgsReverseOrder() {
        dump(mDumper, mFd, mPw, new String[]{"--dump-priority", "NORMAL", "--proto", "--five"});
        verify(mDumper).dumpNormal(same(mFd), same(mPw),
                eq(new String[]{"--five"}), /* asProto= */ eq(true));
    }

    @Test
    public void testProtoArgsInMiddle() {
        dump(mDumper, mFd, mPw, new String[]{"--unknown", "--proto", "--five"});
        verify(mDumper).dump(same(mFd), same(mPw),
                eq(new String[]{"--unknown", "--five"}), /* asProto= */ eq(true));
    }

    @Test
    public void testProtoArgsAtEnd() {
        dump(mDumper, mFd, mPw, new String[]{"args", "-left", "--behind", "--proto"});
        verify(mDumper).dump(same(mFd), same(mPw),
                eq(new String[]{"args", "-left", "--behind"}), /* asProto= */ eq(true));
    }

    @Test
    public void testProtoArgsWithInvalidPriorityType() {
        dump(mDumper, mFd, mPw, new String[]{"--dump-priority", "HIGH?", "--proto"});
        verify(mDumper).dump(same(mFd), same(mPw),
                eq(EMPTY_ARGS), /* asProto= */ eq(true));
    }

    private final class FakeDumper implements PriorityDumper {

        String[] criticalArgs, highArgs, normalArgs;
        FileDescriptor criticalFd, highFd, normalFd;
        PrintWriter criticalPw, highPw, normalPw;

        @Override
        public void dumpCritical(FileDescriptor fd, PrintWriter pw, String[] args,
                boolean asProto) {
            criticalFd = fd;
            criticalPw = pw;
            criticalArgs = args;
        }

        @Override
        public void dumpHigh(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
            highFd = fd;
            highPw = pw;
            highArgs = args;
        }

        @Override
        public void dumpNormal(FileDescriptor fd, PrintWriter pw, String[] args, boolean asProto) {
            normalFd = fd;
            normalPw = pw;
            normalArgs = args;
        }
    }
}