src/js/simulated_radio_tests.js

/**
 * Copyright (C) 2010 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.
 */

/**
 * TODO:update tests in the format of test incoming call
 *      Have a global counter to count passes and failures
 */
/**
 * A test to test set signal strength
 */
if (false) {
    function testSetSignalStrength() {
        print('testSetSignalStrength E:');
        simulatedRadio.printSignalStrength();
        try {
            simulatedRadio.setSignalStrength(0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1);
        } catch (err) {
            print('test failed');
        }
        simulatedRadio.printSignalStrength();
        try {
            simulatedRadio.setSignalStrength(60, 30, 29 , 28, 27, 26, 25, 24, 23, 22, 21, 20);
        } catch (err) {
            print('test success: ' + err);
        }
        simulatedRadio.printSignalStrength();
    }
    testSetSignalStrength();
}

/**
 * TODO: A test for RIL_REQUEST_GET_CURRENT_CALLS,
 *       remove when satisfied all is well.
 */
if (false) {
    var calls = simulatedRadio.getCalls();

    function testCalls() {
        print('testCalls E:');
        var c0 = simulatedRadio.addCall(CALLSTATE_ACTIVE, '16502859848', 'w');
        simulatedRadio.printCalls();
        var c1 = simulatedRadio.addCall(CALLSTATE_ACTIVE, '16502583456', 'm');
        simulatedRadio.printCalls();
        var c2 = simulatedRadio.addCall(CALLSTATE_ACTIVE, '16502345678', 'x');
        simulatedRadio.printCalls();
        var c3 = simulatedRadio.addCall(CALLSTATE_ACTIVE, '16502349876', 'y');
        simulatedRadio.printCalls();

        simulatedRadio.removeCall(c0.index);
        simulatedRadio.printCalls();
        simulatedRadio.removeCall(c1.index);
        simulatedRadio.printCalls();
        simulatedRadio.removeCall(c2.index);
        simulatedRadio.printCalls();

        result = simulatedRadio.rilRequestGetCurrentCalls();
        newCalls = rilSchema[packageNameAndSeperator +
                            'RspGetCurrentCalls'].parse(result.responseProtobuf);
        simulatedRadio.printCalls(newCalls.calls);

        // Set to false to test RIL_REQUEST_GET_CURRENT_CALLS as there will
        // be on call still active on the first RIL_REQUEST_GET_CURRENT_CALLS
        // request.
        if (false) {
            simulatedRadio.removeCall(c3.index);
            simulatedRadio.printCalls();
        }
        print('testCalls X:');
    }

    testCalls();
}

/**
 * A test for creating incoming call
 */
if (false) {
    /* Only one incoming call is in the call list */
    function verifyIncomingCall() {
        var calls = simulatedRadio.getCalls();
        var numIncomingCalls = 0;
        for (var i = 0; i < calls.length; i++) {
            if (typeof calls[i] != 'undefined') {
                if (calls[i].state == CALLSTATE_INCOMING) {
                    numIncomingCalls++;
                }
            }
        }
        return (numIncomingCalls == 1);
    }

    function testStartIncomingCall() {
        print('testCreateIncomingCall E:');

        var req = new Object();
        req.reqNum = CTRL_CMD_SET_MT_CALL;
        req.data = new Object();
        req.data.phoneNumber = '6502249208';

        var numberTestPass = 0;
        var numberTestFail = 0;

        // case 1: incoming call is the only active call
        var result = new Object();
        result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
        if ( (result.rilErrCode == CTRL_STATUS_OK) && verifyIncomingCall()) {
            numberTestPass++;
        } else {
            numberTestFail++;
            print('testStartIncomingCall: TEST CASE 1 FAIL');
        }

        // case 2: one incoming call, add another incoming call will fail
        req.data.phoneNumber = '6502223456';
        result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
        if ((result.rilErrCode == CTRL_STATUS_ERR) && verifyIncomingCall()) {
            numberTestPass++;
        } else {
            numberTestFail++;
            print('testStartIncomingCall: TEST CASE 2 FAIL');
        }

        // case 3: one dialing call, add another incoming call will fail
        // Make the first call in dialing state
        var calls = simulatedRadio.getCalls();
        for (var i = 0; i < calls.length; i++) {
            if (typeof calls[i] != 'undefined') {
                if (calls[i].state == CALLSTATE_INCOMING) {
                    calls[i].state = CALLSTATE_DIALING;
                    break;
                }
            }
        }
        result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
        if (result.rilErrCode == CTRL_STATUS_ERR) {
            numberTestPass++;
        } else {
            numberTestFail++;
            print('testStartIncomingCall: TEST CASE 3 FAIL');
        }

        // case 4: one dialing call, adding another incoming call will fail
        calls[i].state = CALLSTATE_ALERTING;
        result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
        if (result.rilErrCode == CTRL_STATUS_ERR) {
            numberTestPass++;
        } else {
            numberTestFail++;
            print('testStartIncomingCall: TEST CASE 4 FAIL');
        }

        // case 5: one active call, adding another incoming call will succeed
        calls[i].state = CALLSTATE_ACTIVE;
        result = simulatedRadio.ctrlServerCmdStartInComingCall(req);
        if (result.rilErrCode == CTRL_STATUS_OK) {
            numberTestPass++;
        } else {
            numberTestFail++;
            print('testStartIncomingCall: TEST CASE 5 FAIL');
        }

        print('*************TEST RESULT ****************');
        print('Number of Test Passed: ' + numberTestPass);
        print('Number of Test Failed: ' + numberTestFail);
        print('************   End **********************');
        // after the test, remove any calls
        for (i = 0; i < calls.length; i++) {
            simulatedRadio.removeCall(i);
        }
        print('testStartIncomingCall X:');
    }

    testStartIncomingCall();
}

/**
 * A test for RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND
 */
if (false) {
    var calls = simulatedRadio.getCalls();

    function testHangUpForegroundResumeBackground() {
        print('testHangUpForegroundResumeBackground E:');
        var testOutput = false;
        for (var state = CALLSTATE_ACTIVE; state <= CALLSTATE_WAITING; state++) {
            var c0 = simulatedRadio.addCall(state, '16502849230', 'smith');
            var req = new Object();
            req.reqNum = RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND;
            var testResult = simulatedRadio.rilRequestHangUpForegroundResumeBackground(req);
            if (state == CALLSTATE_ACTIVE) {
                var testCalls = simulatedRadio.getCalls();
                if (testCalls.length == 0) {
                    testOutput = true;
                } else {
                    testOutput = false;
                }
            } else if (state == CALLSTATE_WAITING) {
                if (c0.state == CALLSTATE_ACTIVE) {
                    testOutput = true;
                } else {
                    testOutput = false;
                }
            } else if (state == CALLSTATE_HOLDING) {
                if (c0.state == CALLSTATE_ACTIVE) {
                    testOutput = true;
                } else {
                    testOutput = false;
                }
            } else {
                if (testResult.rilErrCode == RIL_E_GENERIC_FAILURE) {
                    testOutput = true;
                } else {
                    testOutput = false;
                }
            }
            if (testOutput == true) {
                print('testHangUpForegroundResumeBackground, call ' + state + ' PASS \n');
            } else {
                print('testHangUpForegroundResumeBackground, call ' + state + ' FAIL \n');
            }
            simulatedRadio.removeCall(c0.index);
            simulatedRadio.printCalls();
        }
    }

    testHangUpForegroundResumeBackground();
}

/**
 * Test RIL_REQUEST_CONFERENCE
 */
if(false) {
    var calls = simulatedRadio.getCalls();

    function testConference() {
        print('testConference E');

        // test case 1: one holding, one dialing
        var c0 = simulatedRadio.addCall(CALLSTATE_HOLDING, '16502859848', 'w');
        simulatedRadio.printCalls();
        var c1 = simulatedRadio.addCall(CALLSTATE_DIALING, '16502583456', 'm');
        simulatedRadio.printCalls();

        var req = new Object();
        req.reqNum = RIL_REQUEST_CONFERENCE;
        var testResult = new Object();
        testResult.rilErrCode = RIL_E_SUCCESS;
        testResult = simulatedRadio.rilRequestConference(req);
        if (testResult.rilErrCode == RIL_E_GENERIC_FAILURE) {
            print('testConference: holding & dialing: pass');
        } else {
            print('testConference: holding & dialing: fail');
        }

        // test case 2: one holding, one alerting
        c1.state = CALLSTATE_ALERTING;
        testResult.rilErrCode = RIL_E_SUCCESS;
        testResult = simulatedRadio.rilRequestConference(req);
        if (testResult.rilErrCode == RIL_E_GENERIC_FAILURE) {
            print('testConference: holding & alerting: pass');
        } else {
            print('testConference: holding & alerting: fail');
        }

        // test case 3: one holding, one active
        c1.state = CALLSTATE_ACTIVE;
        testResult.rilErrCode = RIL_E_SUCCESS;
        testResult = simulatedRadio.rilRequestConference(req);
        if (testResult.rilErrCode == RIL_E_SUCCESS) {
            print('testConference: holding & active: pass');
        } else {
            print('testConference: holding & active: fail');
        }

        // test case 4: one holding, one incoming
        c1.state = CALLSTATE_INCOMING;
        testResult.rilErrCode = RIL_E_SUCCESS;
        testResult = simulatedRadio.rilRequestConference(req);
        if (testResult.rilErrCode == RIL_E_GENERIC_FAILURE) {
            print('testConference: holding & incoming: pass');
        } else {
            print('testConference: holding & incoming: fail');
        }

        // test case 5: one holding, one waiting
        c1.state = CALLSTATE_WAITING;
        testResult.rilErrCode = RIL_E_SUCCESS;
        testResult = simulatedRadio.rilRequestConference(req);
        if (testResult.rilErrCode == RIL_E_GENERIC_FAILURE) {
            print('testConference: holding & waiting: pass');
        } else {
            print('testConference: holding & waiting: fail');
        }

        simulatedRadio.removeCall(c0.index);
        simulatedRadio.removeCall(c1.index);
        print('testConference: X');
    }

    testConference();
}
/**
 * Test serialization of bad numeric enum
 */
if (false) {
    var c = new RilCall(1000, '11234567890', 'me');
    rsp = new Object();
    rsp.calls = [ c ];
    try {
        rilSchema[packageNameAndSeperator + 'RspGetCurrentCalls'].serialize(rsp);
        print('test-enum a bad numeric enum value, FAILURE exception expected');
    } catch (err) {
        print('test-enum a bad numeric enum value, SUCCESS exception expected: ' + err);
    }
}

/**
 * Test serialization of bad string enum
 */
if (false) {
    // The state parameter 'NOT_CALLSTATE_ACTIVE' can get corrupted in ToProto?
    var c = new RilCall('NOT_CALLSTATE_ACTIVE', '11234567890', 'me');
    rsp = new Object();
    rsp.calls = [ c ];
    try {
        rilSchema[packageNameAndSeperator + 'RspGetCurrentCalls'].serialize(rsp);
        print('test-enum a bad string enum value, FAILURE exception expected');
    } catch (err) {
        print('test-enum a bad string enum value, SUCCESS exception expected: ' + err);
    }
}

/**
 * Test addDelayed
 */
if (false) {
    print("test addDelayed E");
    simulatedRadioWorker.add( {
        'reqNum' : CMD_DELAY_TEST,
        'hello' : 'hi no delay' });
    simulatedRadioWorker.addDelayed( {
        'reqNum' : CMD_DELAY_TEST,
        'hello' : 'hi not-a-number is 0 delay' }, "not-a-number");
    simulatedRadioWorker.addDelayed( {
        'reqNum' : CMD_DELAY_TEST,
        'hello' : 'hi negative delay is 0 delay' }, -1000);
    simulatedRadioWorker.addDelayed( {
        'reqNum' : CMD_DELAY_TEST,
        'hello' : 'hi delayed 2 seconds' }, 2000);
    print("test addDelayed X");
}

/**
 * A test for setRadioState, verify it can handle valid string variable,
 * undefined varilabe, and invalid radio state correctly.
 */
if (false) {
    function testSetRadioState() {
        print('testSetRadioState E:');
        // defined string variable
        newState = 'RADIOSTATE_UNAVAILABLE';
        try {
            setRadioState(newState);
        } catch (err) {
            print('test failed');
        }
        print('Expecting gRadioState to be ' + RADIOSTATE_UNAVAILABLE +
              ', gRadioState is: ' + gRadioState);

        // undefined string variable, expecting exception
        try {
            setRadioState('RADIOSTATE_UNDEFINED');
        } catch (err) {
            if (err.indexOf('Unknow string') >= 0) {
                print('test success');
                print('err: ' + err);
            } else {
                print('test failed');
            }
        }

        // valid radio state
        try {
            setRadioState(RADIOSTATE_NV_READY);
        } catch (err) {
            print('test failed');
        }
        print('Expecting gRadioState to be ' + RADIOSTATE_NV_READY +
              ', gRadioState is: ' + gRadioState);

        // invalid radio state
        try {
            setRadioState(-1);
        } catch (err) {
            if (err.indexOf('invalid') >= 0) {
                print('test success');
                print('err: ' + err);
            } else {
                print('test failed, err: ' + err);
            }
        }
        print('gRadioState should not be set: ' + gRadioState);

        // set radio state to be SIM_READY
        setRadioState(RADIOSTATE_SIM_READY);
        print('Expecting gRadioState to be ' + RADIOSTATE_SIM_READY +
              ', gRadioState is: ' + gRadioState);
        print('testSetRadioState X:');
    }

    testSetRadioState();
}