/*
* Copyright (C) 2007 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.core;
import android.bluetooth.AtCommandHandler;
import android.bluetooth.AtCommandResult;
import android.bluetooth.AtParser;
import java.util.*;
import junit.framework.*;
public class AtParserTest extends TestCase {
/* An AtCommandHandler instrumented for testing purposes
*/
private class HandlerTest extends AtCommandHandler {
boolean mBasicCalled, mActionCalled, mReadCalled, mTestCalled,
mSetCalled;
int mBasicReturn, mActionReturn, mReadReturn, mTestReturn, mSetReturn;
Object[] mSetArgs;
String mBasicArgs;
HandlerTest() {
this(AtCommandResult.ERROR, AtCommandResult.ERROR,
AtCommandResult.ERROR, AtCommandResult.ERROR,
AtCommandResult.ERROR);
}
HandlerTest(int a, int b, int c, int d, int e) {
mBasicReturn = a;
mActionReturn = b;
mReadReturn = c;
mSetReturn = d;
mTestReturn = e;
reset();
}
public void reset() {
mBasicCalled = false;
mActionCalled = false;
mReadCalled = false;
mSetCalled = false;
mTestCalled = false;
mSetArgs = null;
mBasicArgs = null;
}
public boolean wasCalled() { // helper
return mBasicCalled || mActionCalled || mReadCalled ||
mTestCalled || mSetCalled;
}
@Override
public AtCommandResult handleBasicCommand(String args) {
mBasicCalled = true;
mBasicArgs = args;
return new AtCommandResult(mBasicReturn);
}
@Override
public AtCommandResult handleActionCommand() {
mActionCalled = true;
return new AtCommandResult(mActionReturn);
}
@Override
public AtCommandResult handleReadCommand() {
mReadCalled = true;
return new AtCommandResult(mReadReturn);
}
@Override
public AtCommandResult handleSetCommand(Object[] args) {
mSetCalled = true;
mSetArgs = args;
return new AtCommandResult(mSetReturn);
}
@Override
public AtCommandResult handleTestCommand() {
mTestCalled = true;
return new AtCommandResult(mTestReturn);
}
}
private AtParser mParser;
@Override
protected void setUp() throws Exception {
super.setUp();
mParser = new AtParser();
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
/* Test that the right method is being called
*/
/* public void testBasic1() throws Exception {
HandlerTest D = new HandlerTest(0, 1, 1, 1, 1);
HandlerTest A = new HandlerTest(0, 1, 1, 1, 1);
mParser.register('D', D);
mParser.register('A', A);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process(" A T D = ? T 1 2 3 4 ").toStrings()));
assertTrue(D.mBasicCalled);
assertFalse(D.mActionCalled);
assertFalse(D.mTestCalled);
assertFalse(D.mSetCalled);
assertFalse(D.mReadCalled);
assertFalse(A.wasCalled());
assertEquals("=?T1234", D.mBasicArgs);
}
*/
/* Test some crazy strings
*//*
public void testBasic2() throws Exception {
HandlerTest A = new HandlerTest(0, 1, 1, 1, 1);
mParser.register('A', A);
assertTrue(Arrays.equals(
new String[]{},
mParser.process(" ").toStrings()));
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process(" a T a t \"\" 1 2 3 a 4 ")
.toStrings()));
assertEquals("T\"\"123A4", A.mBasicArgs);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process(" a T a t \"foo BaR12Z\" 1 2 3 a 4 ")
.toStrings()));
assertEquals("T\"foo BaR12Z\"123A4", A.mBasicArgs);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("ATA\"").toStrings()));
assertEquals("\"\"", A.mBasicArgs);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("ATA\"a").toStrings()));
assertEquals("\"a\"", A.mBasicArgs);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("ATa\" ").toStrings()));
assertEquals("\" \"", A.mBasicArgs);
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("ATA \"one \" two \"t hr ee ")
.toStrings()));
assertEquals("\"one \"TWO\"t hr ee \"", A.mBasicArgs);
}*/
/* Simple extended commands
*//*
public void testExt1() throws Exception {
HandlerTest A = new HandlerTest(1, 0, 0, 0, 0);
mParser.register("+A", A);
assertTrue(Arrays.equals(
new String[]{"ERROR"},
mParser.process("AT+B").toStrings()));
assertFalse(A.wasCalled());
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+A").toStrings()));
assertTrue(A.mActionCalled);
A.mActionCalled = false;
assertFalse(A.wasCalled());
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+A=").toStrings()));
assertTrue(A.mSetCalled);
A.mSetCalled = false;
assertFalse(A.wasCalled());
assertEquals(1, A.mSetArgs.length);
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+A=?").toStrings()));
assertTrue(A.mTestCalled);
A.mTestCalled = false;
assertFalse(A.wasCalled());
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+A?").toStrings()));
assertTrue(A.mReadCalled);
A.mReadCalled = false;
assertFalse(A.wasCalled());
A.reset();
}
*/
/* Test chained commands
*//*
public void testChain1() throws Exception {
HandlerTest A = new HandlerTest(0, 1, 1, 1, 1);
HandlerTest B = new HandlerTest(1, 0, 0, 0, 0);
HandlerTest C = new HandlerTest(1, 1, 1, 1, 1);
mParser.register('A', A);
mParser.register("+B", B);
mParser.register("+C", C);
assertTrue(Arrays.equals(
new String[]{"ERROR"},
mParser.process("AT+B;+C").toStrings()));
assertTrue(B.mActionCalled);
assertTrue(C.mActionCalled);
B.reset();
C.reset();
assertTrue(Arrays.equals(
new String[]{"ERROR"},
mParser.process("AT+C;+B").toStrings()));
assertFalse(B.wasCalled());
assertTrue(C.mActionCalled);
B.reset();
C.reset();
}*/
/* Test Set command
*//*
public void testSet1() throws Exception {
HandlerTest A = new HandlerTest(1, 1, 1, 0, 1);
mParser.register("+AAAA", A);
Object[] expectedResult;
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=1").toStrings()));
expectedResult = new Object[]{(Integer)1};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=1,2,3").toStrings()));
expectedResult = new Object[]{(Integer)1, (Integer)2, (Integer)3};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=3,0,0,1").toStrings()));
expectedResult = new Object[]{(Integer)3, (Integer)0, (Integer)0,
(Integer)1};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=\"foo\",1,\"b,ar").toStrings()));
expectedResult = new Object[]{"\"foo\"", 1, "\"b,ar\""};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=").toStrings()));
expectedResult = new Object[]{""};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=,").toStrings()));
expectedResult = new Object[]{"", ""};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=,,,").toStrings()));
expectedResult = new Object[]{"", "", "", ""};
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("AT+AAAA=,1,,\"foo\",").toStrings()));
expectedResult = new Object[]{"", 1, "", "\"foo\"", ""};
assertEquals(5, A.mSetArgs.length);
assertTrue(Arrays.equals(expectedResult, A.mSetArgs));
A.reset();
}*/
/* Test repeat command "A/"
*//*
public void testRepeat() throws Exception {
HandlerTest A = new HandlerTest(0, 0, 0, 0, 0);
mParser.register('A', A);
// Try repeated command on fresh parser
assertTrue(Arrays.equals(
new String[]{},
mParser.process("A/").toStrings()));
assertFalse(A.wasCalled());
A.reset();
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("ATA").toStrings()));
assertTrue(A.mBasicCalled);
assertEquals("", A.mBasicArgs);
A.reset();
// Now repeat the command
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("A/").toStrings()));
assertTrue(A.mBasicCalled);
assertEquals("", A.mBasicArgs);
A.reset();
// Multiple repeats
assertTrue(Arrays.equals(
new String[]{"OK"},
mParser.process("A/").toStrings()));
assertTrue(A.mBasicCalled);
assertEquals("", A.mBasicArgs);
A.reset();
}*/
}