java类android.test.suitebuilder.annotation.Suppress的实例源码

/**
 * Tests international matching issues for the PHONE_NUMBERS_EQUAL function.
 * 
 * @throws Exception
 */
@Suppress // PHONE_NUMBERS_EQUAL not supported
@SmallTest
public void testPhoneNumbersEqualInternationl() throws Exception {
    assertPhoneNumberEqual("1", "1");
    assertPhoneNumberEqual("123123", "123123");
    assertPhoneNumberNotEqual("123123", "923123");
    assertPhoneNumberNotEqual("123123", "123129");
    assertPhoneNumberNotEqual("123123", "1231234");
    assertPhoneNumberNotEqual("123123", "0123123", false);
    assertPhoneNumberNotEqual("123123", "0123123", true);
    assertPhoneNumberEqual("650-253-0000", "6502530000");
    assertPhoneNumberEqual("650-253-0000", "650 253 0000");
    assertPhoneNumberEqual("650 253 0000", "6502530000");
    assertPhoneNumberEqual("+1 650-253-0000", "6502530000");
    assertPhoneNumberEqual("001 650-253-0000", "6502530000");
    assertPhoneNumberEqual("0111 650-253-0000", "6502530000");

    // Russian trunk digit
    assertPhoneNumberEqual("+79161234567", "89161234567");

    // French trunk digit
    assertPhoneNumberEqual("+33123456789", "0123456789");

    // Trunk digit for city codes in the Netherlands
    assertPhoneNumberEqual("+31771234567", "0771234567");

    // Test broken caller ID seen on call from Thailand to the US
    assertPhoneNumberEqual("+66811234567", "166811234567");

    // Test the same in-country number with different country codes
    assertPhoneNumberNotEqual("+33123456789", "+1123456789");

    // Test one number with country code and the other without
    assertPhoneNumberEqual("5125551212", "+15125551212");

    // Test two NANP numbers that only differ in the area code
    assertPhoneNumberNotEqual("5125551212", "6505551212");

    // Japanese phone numbers
    assertPhoneNumberEqual("090-1234-5678", "+819012345678");
    assertPhoneNumberEqual("090(1234)5678", "+819012345678");
    assertPhoneNumberEqual("090-1234-5678", "+81-90-1234-5678");

    // Equador
    assertPhoneNumberEqual("+593(800)123-1234", "8001231234");
    assertPhoneNumberEqual("+593-2-1234-123", "21234123");

    // Two continuous 0 at the beginning of the phone string should not be
    // treated as trunk prefix in the strict comparation.
    assertPhoneNumberEqual("008001231234", "8001231234", false);
    assertPhoneNumberNotEqual("008001231234", "8001231234", true);

    // Confirm that the bug found before does not re-appear in the strict compalation
    assertPhoneNumberEqual("080-1234-5678", "+819012345678", false);
    assertPhoneNumberNotEqual("080-1234-5678", "+819012345678", true);
}

@Suppress
public void testTeNumberhasHint() {
    String hint = mTeNumber.getHint().toString();
    assertNotNull(hint);
    assertEquals(com.mevelopers.tabdilak.R.string.TeNumberDefaultText, hint);
}

@Suppress
public void testSupportedScreenSizes() {
    //Tests to see if we have <support-screens> tags in our manifest or not?!
    fail("<supports-screens> not implemented yet!");
}

@Suppress
public void testTvResultFontSize() {
    final float expected = 54.0f;
    assertEquals(expected, mTvResult.getTextSize());

}

@Suppress
public void testBeanSketchUpload() throws Exception {
    final Bean bean = discoverBean();
    synchronousConnect(bean);
    String hwVersion = getDeviceInformation(bean).hardwareVersion();

    String hexPath = null;
    for (String filename : filesInAssetDir(getContext(), "bean_fw_advanced_callbacks")) {
        if (FilenameUtils.getExtension(filename).equals("hex")) {
            String[] pieces = FilenameUtils.getBaseName(filename).split("_");
            String hexHW = pieces[pieces.length - 1];
            if (hexHW.equals(hwVersion)) {
                hexPath = FilenameUtils.concat("bean_fw_advanced_callbacks", filename);
                break;
            }
        }
    }

    assertThat(hexPath).isNotNull();
    InputStream imageStream  = getContext().getAssets().open(hexPath);
    StringWriter writer = new StringWriter();
    IOUtils.copy(imageStream, writer);

    String timestamp = Long.toString(System.currentTimeMillis() / 1000);
    SketchHex sketchHex = SketchHex.create(timestamp, writer.toString());

    final CountDownLatch sketchLatch = new CountDownLatch(1);
    Callback<UploadProgress> onProgress = new Callback<UploadProgress>() {
        @Override
        public void onResult(UploadProgress result) {
            System.out.println("On Result: " + result);
        }
    };

    Runnable onComplete = new Runnable() {
        @Override
        public void run() {
            System.out.println("all done!");
            sketchLatch.countDown();
        }
    };

    bean.programWithSketch(sketchHex, onProgress, onComplete);
    sketchLatch.await(120, TimeUnit.SECONDS);

    SketchMetadata metadata = getSketchMetadata(bean);
    if (!metadata.hexName().equals(timestamp)) {
        fail(String.format("Unexpected Sketch name: %s != %s", metadata.hexName(), timestamp));
    }
}

@Suppress
public void testConnectMultipleBeansWithSameListener() throws InterruptedException {
    /* This test requires at least 3 beans nearby to pass */

    final List<Bean> beans = discoverBeans(3);
    final Bean beanA = beans.get(0);
    final Bean beanB = beans.get(1);
    final Bean beanC = beans.get(2);
    final CountDownLatch connectionLatch = new CountDownLatch(2);
    final HashMap<String, Boolean> connectionState = new HashMap<>();
    connectionState.put("bean_a_connected", false);
    connectionState.put("bean_b_connected", false);

    BeanListener beanListener = new BeanListener() {

        @Override
        public void onConnected() {
            if (connectionState.get("bean_a_connected") == false) {
                if (beanA.isConnected()) {
                    connectionState.put("bean_a_connected", true);
                    connectionLatch.countDown();
                }
            }

            if (connectionState.get("bean_b_connected") == false) {
                if (beanB.isConnected()) {
                    connectionState.put("bean_b_connected", true);
                    connectionLatch.countDown();
                }
            }

            if (beanC.isConnected()) {
                fail("Bean C not suppose to connect!");
            }
        }

        @Override
        public void onConnectionFailed() {
            fail("Connection failed!");
        }

        @Override
        public void onDisconnected() {
        }

        @Override
        public void onSerialMessageReceived(byte[] data) {
        }

        @Override
        public void onScratchValueChanged(ScratchBank bank, byte[] value) {
        }

        @Override
        public void onError(BeanError error) {
            fail(error.toString());
        }

        @Override
        public void onReadRemoteRssi(final int rssi) {
            System.out.println("onReadRemoteRssi: " + rssi);
        }
    };

    beanA.connect(getContext(), beanListener);
    beanB.connect(getContext(), beanListener);
    connectionLatch.await(60, TimeUnit.SECONDS);
    // No need to assert anything, implicit success based on connection latch
}

@Suppress
    public void testCreateDatabaseColumn() throws Exception {
        final CountDownLatch signal = new CountDownLatch(1);

        // String columnName = "Custom Integration Test Id";
        // String columnName = "Mobile User Id";
        // String columnName = getEngageConfigManager().mergedRecipientIdColumnName();
//        String columnName = getEngageConfigManager().mergedDateColumnName();
        String columnName = "Custom Integration Test Id 2";

        int columnType = XMLAPIColumnType.TEXT_COLUMN.code();
//        int columnType = XMLAPIColumnType.TIMESTAMP.value();

        XMLAPI addListColumnXml = XMLAPI.builder()
                .operation(XMLAPIOperation.ADD_LIST_COLUMN)
                .listId(getEngageConfigManager().engageListId())
                .param(XMLAPIElement.COLUMN_NAME, columnName)
                .param(XMLAPIElement.COLUMN_TYPE, columnType)
                 //  .param(XMLAPIElement.DEFAULT, "")
                .build();

        getXMLAPIManager().postXMLAPI(addListColumnXml, new XMLAPIResponseHandler() {
            @Override
            public void onSuccess(EngageResponseXML response) {
                String xml = response.getXml();
                Log.i(TAG, xml);

                if (!response.isSuccess()) {
                    fail(response.getFaultString());
                }

                signal.countDown();
            }

            @Override
            public void onFailure(XMLAPIResponseFailure exception) {
                fail();
            }
        });

        signal.await(10, TimeUnit.SECONDS);
    }

@Suppress
public void testCreateAuditRecordTable() throws Exception {
    final CountDownLatch signal = new CountDownLatch(1);

    XMLAPI addListColumnXml = new XMLAPI(XMLAPIOperation.CREATE_TABLE) {
        // one way to hack the xml object ...you really shouldn't do this though... its not guaranteed to work forever
        @Override
        public String envelope() {
            return "<Envelope>\n" +
                    "\t<Body>\n" +
                    "\t\t<CreateTable>\n" +
                    "\t\t\t<TABLE_NAME>Audit Record Test</TABLE_NAME>\n" +
                    "\t\t\t<COLUMNS>\n" +
                    "\t\t\t\t<COLUMN>\n" +
                    "\t\t\t\t\t<NAME>Audit Record Id</NAME>\n" +
                    "\t\t\t\t\t<TYPE>TEXT</TYPE>\n" +
                    "\t\t\t\t\t<IS_REQUIRED>true</IS_REQUIRED>\n" +
                    "\t\t\t\t\t<KEY_COLUMN>true</KEY_COLUMN>\n" +
                    "\t\t\t\t</COLUMN>\n" +
                    "\t\t\t\t<COLUMN>\n" +
                    "\t\t\t\t\t<NAME>Old Recipient Id</NAME>\n" +
                    "\t\t\t\t\t<TYPE>TEXT</TYPE>\n" +
                    "\t\t\t\t\t<IS_REQUIRED>true</IS_REQUIRED>\n" +
                    "\t\t\t\t</COLUMN>\n" +
                    "\t\t\t\t<COLUMN>\n" +
                    "\t\t\t\t\t<NAME>New Recipient Id</NAME>\n" +
                    "\t\t\t\t\t<TYPE>TEXT</TYPE>\n" +
                    "\t\t\t\t\t<IS_REQUIRED>true</IS_REQUIRED>\n" +
                    "\t\t\t\t</COLUMN>\n" +
                    "\t\t\t\t<COLUMN>\n" +
                    "\t\t\t\t\t<NAME>Create Date</NAME>\n" +
                    "\t\t\t\t\t<TYPE>DATE_TIME</TYPE>\n" +
                    "\t\t\t\t\t<IS_REQUIRED>true</IS_REQUIRED>\n" +
                    "\t\t\t\t</COLUMN>\n" +
                    "\t\t\t</COLUMNS>\n" +
                    "\t\t</CreateTable>\n" +
                    "\t</Body>\n" +
                    "</Envelope>";
        }
    };

    getXMLAPIManager().postXMLAPI(addListColumnXml, new XMLAPIResponseHandler() {
        @Override
        public void onSuccess(EngageResponseXML response) {
            String xml = response.getXml();
            Log.i(TAG, xml);

            if (!response.isSuccess()) {
                fail(response.getFaultString());
            }

            signal.countDown();
        }

        @Override
        public void onFailure(XMLAPIResponseFailure exception) {
            fail();
        }
    });

    signal.await(10, TimeUnit.SECONDS);
}

@Suppress
private List<String> added(Collection d) {
    return d.getMedia().getDb().queryColumn(String.class, "select fname from media where csum is not null", 0);
}

@Suppress
private List<String> removed(Collection d) {
    return d.getMedia().getDb().queryColumn(String.class, "select fname from media where csum is null", 0);
}