platformsuitabilityfiltertests.java.svn-base

来自「cqME :java framework for TCK test.」· SVN-BASE 代码 · 共 255 行

/*
 * $Id$
 *
 * Copyright 1996-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 *
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 *
 */

package com.sun.tck.j2me.platform;

import java.util.Properties;

import com.sun.javatest.TestDescription;
import com.sun.javatest.TestEnvironment;
import com.sun.javatest.TestFilter;
import com.sun.javatest.TestFilter.Fault;
import com.sun.tck.unitTests.lib.TdUtils;
import com.sun.tck.unitTests.lib.TestEnvUtils;

import junit.framework.TestCase;

public class PlatformSuitabilityFilterTests extends TestCase {
    TestFilter[] filters;

    private TestEnvironment midpTestEnv;
    private PlatformSuitabilityFilter midpFilter;

    private TestEnvironment cldcTestEnv;
    private PlatformSuitabilityFilter cldcFilter;

    private TestEnvironment cdcTestEnv;
    private PlatformSuitabilityFilter cdcFilter;;

    private TestEnvironment customTestEnv;
    private PlatformSuitabilityFilter customFilter;

    private TestEnvironment invalidTestEnv;
    private PlatformSuitabilityFilter invalidEnvFilter;

    public static void main(String[] args) {
        junit.textui.TestRunner.run(PlatformSuitabilityFilterTests.class);
    }

    protected void setUp() throws Exception {
        super.setUp();
        Properties props = new Properties();
        props.setProperty(BasePlatformInfo.PLATFORM_KEY, "MIDP");
        midpTestEnv = TestEnvUtils.createTestEnv(props);
        midpFilter = new PlatformSuitabilityFilter(midpTestEnv);

        props.setProperty(BasePlatformInfo.PLATFORM_KEY, "CLDC");
        cldcTestEnv = TestEnvUtils.createTestEnv(props);
        cldcFilter = new PlatformSuitabilityFilter(cldcTestEnv);

        props.setProperty(BasePlatformInfo.PLATFORM_KEY, "CDC");
        cdcTestEnv = TestEnvUtils.createTestEnv(props);
        cdcFilter = new PlatformSuitabilityFilter(cdcTestEnv);

        props.setProperty(BasePlatformInfo.PLATFORM_KEY, "CUSTOM_MODE");
        customTestEnv = TestEnvUtils.createTestEnv(props);
        customFilter = new PlatformSuitabilityFilter(customTestEnv);

        invalidTestEnv = TestEnvUtils.createTestEnv(new Properties());
        invalidEnvFilter = new PlatformSuitabilityFilter(invalidTestEnv);

        filters = new TestFilter[5];
        filters[0] = midpFilter;
        filters[1] = cldcFilter;
        filters[2] = cdcFilter;
        filters[3] = customFilter;
        filters[4] = invalidEnvFilter;
    }

    protected void tearDown() throws Exception {
        super.tearDown();
    }

    /*
     * Tests for constructor. Ctor should never fail.
     */
    public void testPlatformSuitabilityFilter() {
        for (int i = 0; i < filters.length; i++) {
            assertNotNull(filters[i]);
        }
    }

    public void testGetName() {
        for (int i = 0; i < filters.length; i++) {
            assertNotNull(filters[i].getName());
        }
    }

    public void testGetDescription() {
        for (int i = 0; i < filters.length; i++) {
            assertNotNull(filters[i].getDescription());
        }

    }

    public void testGetReason() {
        for (int i = 0; i < filters.length; i++) {
            assertNotNull(filters[i].getReason());
        }
    }

    /*
     * Use case: platforms specified explicitly in the test.
     */
    public void testAcceptsTestDescriptionWithExplicitPlatforms()
            throws TestFilter.Fault {

        TestDescription tdForAllPlatforms = TdUtils.createWithProps(
                new Properties());
        for (int i = 0; i < filters.length; i++) {
            assertTrue(filters[i].accepts(tdForAllPlatforms));
        }

        Properties props = new Properties();
        props.setProperty(
                PlatformSuitabilityFilter.SUITABLE_PLATFORM_KEY,
                "midp, cdc, cldc");
        tdForAllPlatforms = TdUtils.createWithProps(new Properties());
        for (int i = 0; i < filters.length; i++) {
            assertTrue(filters[i].accepts(tdForAllPlatforms));
        }

        props.setProperty(
                PlatformSuitabilityFilter.SUITABLE_PLATFORM_KEY,
                "midp, cldc");
        TestDescription tdForMidpCldc = TdUtils.createWithProps(props);
        assertTrue(midpFilter.accepts(tdForMidpCldc));
        assertTrue(cldcFilter.accepts(tdForMidpCldc));
        // filter with invalid env permits everything
        assertTrue(invalidEnvFilter.accepts(tdForMidpCldc));
        assertFalse(cdcFilter.accepts(tdForMidpCldc));
        assertFalse(customFilter.accepts(tdForMidpCldc));
    }

    /*
     * Use case: trusted-untrusted without specified platforms.
     */
    public void testAcceptsTestDescriptionWithTrustedUntrustedKw()
            throws TestFilter.Fault {
        Properties props;
        props = new Properties();
        props.setProperty("keywords", "trusted");
        TestDescription tdTrusted = TdUtils.createWithProps(props);
        props.setProperty("keywords", "untrusted");
        TestDescription tdUntrusted = TdUtils.createWithProps(props);

        assertTrue(midpFilter.accepts(tdTrusted));
        assertTrue(midpFilter.accepts(tdUntrusted));

        // filter with invalid env permits everything
        assertTrue(invalidEnvFilter.accepts(tdTrusted));
        assertTrue(invalidEnvFilter.accepts(tdUntrusted));

        assertFalse(cldcFilter.accepts(tdTrusted));
        assertFalse(cldcFilter.accepts(tdUntrusted));

        assertFalse(cdcFilter.accepts(tdTrusted));
        assertFalse(cdcFilter.accepts(tdUntrusted));

        assertFalse(customFilter.accepts(tdTrusted));
        assertFalse(customFilter.accepts(tdUntrusted));
    }

    /*
     * Use case: trusted-untrusted with explicitly specified platforms.
     */
    public void testAcceptsTestDescriptionWithTrustedUntrustedKwAndPlatforms()
            throws TestFilter.Fault {
        Properties props;
        props = new Properties();
        props.setProperty("keywords", "trusted");
        props.setProperty(
                PlatformSuitabilityFilter.SUITABLE_PLATFORM_KEY,
                "midp, cldc");
        TestDescription tdTrusted = TdUtils.createWithProps(props);
        props.setProperty("keywords", "untrusted");
        TestDescription tdUntrusted = TdUtils.createWithProps(props);

        assertTrue(midpFilter.accepts(tdTrusted));
        assertTrue(midpFilter.accepts(tdUntrusted));

        // filter with invalid env permits everything
        assertTrue(invalidEnvFilter.accepts(tdTrusted));
        assertTrue(invalidEnvFilter.accepts(tdUntrusted));

        assertTrue(cldcFilter.accepts(tdTrusted));
        assertTrue(cldcFilter.accepts(tdUntrusted));

        assertFalse(cdcFilter.accepts(tdTrusted));
        assertFalse(cdcFilter.accepts(tdUntrusted));

        assertFalse(customFilter.accepts(tdTrusted));
        assertFalse(customFilter.accepts(tdUntrusted));
    }

    /*
     * Use case: trusted-untrusted with explicitly specified platforms, but no
     * MIDP among them. Midp filter should reject such tests, since MIDP is
     * not specified among applicable platforms.
     */
    public void testAcceptsTestDescriptionWithTrustedUntrustedKwAndPlatformsButNoMidp()
            throws TestFilter.Fault {
        Properties props;
        props = new Properties();
        props.setProperty("keywords", "trusted");
        props.setProperty(
                PlatformSuitabilityFilter.SUITABLE_PLATFORM_KEY,
                "cdc, cldc");  // no midp!
        TestDescription tdTrusted = TdUtils.createWithProps(props);
        props.setProperty("keywords", "untrusted");
        TestDescription tdUntrusted = TdUtils.createWithProps(props);

        // main check:
        assertFalse(midpFilter.accepts(tdTrusted));
        assertFalse(midpFilter.accepts(tdUntrusted));

        // filter with invalid env permits everything
        assertTrue(invalidEnvFilter.accepts(tdTrusted));
        assertTrue(invalidEnvFilter.accepts(tdUntrusted));

        assertTrue(cldcFilter.accepts(tdTrusted));
        assertTrue(cldcFilter.accepts(tdUntrusted));

        assertTrue(cdcFilter.accepts(tdTrusted));
        assertTrue(cdcFilter.accepts(tdUntrusted));

        assertFalse(customFilter.accepts(tdTrusted));
        assertFalse(customFilter.accepts(tdUntrusted));
    }
    
}