alarmcontrollertest.java

来自「This is a resource based on j2me embedde」· Java 代码 · 共 508 行 · 第 1/2 页

					      InterruptedException {
        final FiredChecker firedChecker = new FiredChecker(17, "com.sun.Foo");

        registerAndWait(firedChecker);
        final long previous = firedChecker.registerCheckedAlarm(10001L);
        firedChecker.alarmController.dispose();

        assertEquals(0L, previous);
    }

    private static boolean checkNoAlarms(final Store store) {
        final boolean noAlarms [] = { true };
        store.listAlarms(new Store.AlarmsConsumer() {
		public void consume(final int suiteId, final Map alarms) {
		    /*
		     * NOTE: store shouldn't report suites without alarms
		     * (empty map)
		     */
		    noAlarms[0] = false;
		}
	    });
        return noAlarms[0];
    }
    
    public void testNoRecordAfterFiring() throws IOException,
						 InterruptedException {
        final Store store = createStore();
        final FiredChecker firedChecker = new FiredChecker(store, 17,
							   "com.sun.Foo");

        registerAndWait(firedChecker);
        firedChecker.alarmController.dispose();

        assertTrue(checkNoAlarms(store));
    }

    public void testNotFiredStored() throws IOException, InterruptedException {
        final int MIDLET_SUITE_ID = 17;
        final String MIDLET = "com.sun.Foo";

        final Store store = createStore();
        final FiredChecker firedChecker = new FiredChecker(store,
							   MIDLET_SUITE_ID,
							   MIDLET);

        final long time = System.currentTimeMillis() + 1001L;
        firedChecker.alarmController.registerAlarm(MIDLET_SUITE_ID, MIDLET,
						   time);
        firedChecker.alarmController.dispose();
        if (firedChecker.hasBeenFired()) {
            fail("Test is not reliable: the alarm has been fired");
        }

        final boolean alarmPresent [] = { false };
        final boolean otherAlarmsPresent [] = { false };
        store.listAlarms(new Store.AlarmsConsumer() {
           public void consume(final int suiteId, final Map alarms) {
               if (suiteId != MIDLET_SUITE_ID) {
                   otherAlarmsPresent[0] = true;
                   return;
               }
               if (alarms.size() > 1) {
                   otherAlarmsPresent[0] = true;
                   return;
               }
               final Long t = (Long) alarms.get(MIDLET);
               if ((t == null) || (t.longValue() != time)) {
                   otherAlarmsPresent[0] = true;
                   return;
               }
               alarmPresent[0] = true;
           }
        });
        assertTrue(alarmPresent[0]);
        assertFalse(otherAlarmsPresent[0]);
    }

    public void testAlarmRecordRead() throws IOException, InterruptedException {
        final int MIDLET_SUITE_ID = 17;
        final String MIDLET = "com.sun.Foo";

        final Store store = createStore();
        final long time = System.currentTimeMillis() + 501L;
        store.addAlarm(MIDLET_SUITE_ID, MIDLET, time);

        final FiredChecker firedChecker = new FiredChecker(store, 
							   MIDLET_SUITE_ID,
							   MIDLET);

        Thread.sleep(3*(time - System.currentTimeMillis()));
        firedChecker.alarmController.dispose();
        assertTrue(firedChecker.hasBeenFired());
    }

    public void testPassedAlarmImmediatelyScheduled()
	throws IOException, InterruptedException {
        final int MIDLET_SUITE_ID = 17;
        final String MIDLET = "com.sun.Foo";

        final Store store = createStore();
        final long time = System.currentTimeMillis() - 501L;
        store.addAlarm(MIDLET_SUITE_ID, MIDLET, time);

        final FiredChecker firedChecker = new FiredChecker(store,
							   MIDLET_SUITE_ID,
							   MIDLET);

        Thread.sleep(101L); // just a small delta
        firedChecker.alarmController.dispose();
        assertTrue(firedChecker.hasBeenFired());
    }

    public void testSuiteUninstallPersistentStore() throws IOException {
        final int MIDLET_SUITE_ID = 17;
        final String MIDLET_1 = "com.sun.Foo";
        final String MIDLET_2 = "com.sun.Bar";

        final Store store = createStore();
        final AlarmController alarmController = createAlarmController(store);

        registerAlarmWithDelta(alarmController, MIDLET_SUITE_ID, MIDLET_1,
			       1001L);
        registerAlarmWithDelta(alarmController, MIDLET_SUITE_ID, MIDLET_2,
			       2001L);
        alarmController.removeSuiteAlarms(MIDLET_SUITE_ID);
        alarmController.dispose();

        assertTrue(checkNoAlarms(store));
    }

    public void testSuiteUninstallPersistentStore2()
	throws IOException, InterruptedException {
        final int MIDLET_SUITE_ID_1 = 17;
        final String MIDLET_11 = "com.sun.Foo";
        final long DELTA = 47L;
        final String MIDLET_12 = "com.sun.Bar";

        final int MIDLET_SUITE_ID_2 = 13;
        final String MIDLET_21 = "com.sun.Qux";

        final Store store = createStore();
        final FiredChecker firedChecker = new FiredChecker(store,
							   MIDLET_SUITE_ID_1,
							   MIDLET_11);

        registerAlarmWithDelta(firedChecker.alarmController,
			       MIDLET_SUITE_ID_1, MIDLET_11, DELTA);
        registerAlarmWithDelta(firedChecker.alarmController, 
			       MIDLET_SUITE_ID_2, MIDLET_21, 3001L);
        registerAlarmWithDelta(firedChecker.alarmController,
			       MIDLET_SUITE_ID_1, MIDLET_12, 2001L);
        Thread.sleep(3*DELTA);
        firedChecker.alarmController.dispose();
        if (!firedChecker.hasBeenFired()) {
            fail("Test is not reliable: the alarm hasn't been fired");
        }

        final boolean [] suite1ok = { false };
        final boolean [] suite2ok = { false };
        final boolean [] noOthers = { true };
        store.listAlarms(new Store.AlarmsConsumer() {
           public void consume(final int suiteId, final Map alarms) {
               switch (suiteId) {
                   case MIDLET_SUITE_ID_1:
                       if (alarms.size() > 1) {
                           noOthers[0] = false;
                       } else if (alarms.containsKey(MIDLET_12)) {
                           suite1ok[0] = true;
                       }
                       break;

                   case MIDLET_SUITE_ID_2:
                       if (alarms.size() > 1) {
                           noOthers[0] = false;
                       } else if (alarms.containsKey(MIDLET_21)) {
                           suite2ok[0] = true;
                       }
                       break;

                   default:
                       noOthers[0] = false;
               }
           }
        });
        assertTrue("Suite 1 is incorrect", suite1ok[0]);
        assertTrue("Suite 2 is incorrect", suite2ok[0]);
        assertTrue("Unexpected registrations", noOthers[0]);
    }

    public void testCoupleMidletFirstRegistration() throws IOException {
        final long ALARM_DELTA = 1001L; // in ms

        final int MIDLET_SUITE_ID = 17;
        final String MIDLET_1 = "com.sun.Foo";
        final String MIDLET_2 = "com.sun.Bar";

        final FiredChecker firedChecker = new FiredChecker(MIDLET_SUITE_ID,
							   MIDLET_1);
        final AlarmController alarmController = firedChecker.alarmController;

        registerAlarmWithDelta(alarmController, MIDLET_SUITE_ID, MIDLET_1,
			       ALARM_DELTA);
        final long previous = registerAlarmWithDelta(alarmController, 
						     MIDLET_SUITE_ID,
						     MIDLET_2, 2*ALARM_DELTA);
        if (firedChecker.hasBeenFired()) {
            fail("Test is not reliable: the alarm has been fired." +
		 "  Please, increase ALARM_DELTA");
        }

        alarmController.dispose();

        assertEquals(0L, previous);
    }

    public void testThrowingLifecycleAdapter()
            throws IOException, InterruptedException {
        final long ALARM_DELTA = 101L; // in ms
        final long WAIT_DELAY = 3*ALARM_DELTA;

        final int MIDLET_SUITE_ID = 17;
        final String MIDLET = "com.sun.Foo";

        final ListingLifecycleAdapter listingLifecycleAdapter =
                new ListingLifecycleAdapter();

        final LifecycleAdapter throwingLifecycleAdapter =
                new ThrowingLifecycleAdapter();

        final ProxyLifecycleAdapter lifecycleAdapter =
                new ProxyLifecycleAdapter();

        final AlarmController alarmController =
                createAlarmController(lifecycleAdapter);

        lifecycleAdapter.setProxy(throwingLifecycleAdapter);
        registerAlarmWithDelta(alarmController, MIDLET_SUITE_ID,
			       MIDLET, ALARM_DELTA);
        Thread.sleep(WAIT_DELAY);

        // And now check that everything is ok despite of previously 
	// thrown adapter
        lifecycleAdapter.setProxy(listingLifecycleAdapter);
        registerAlarmWithDelta(alarmController, MIDLET_SUITE_ID,
			       MIDLET, ALARM_DELTA);
        Thread.sleep(WAIT_DELAY);
        alarmController.dispose();

        assertTrue(listingLifecycleAdapter
		   .hasBeenInvokedOnceFor(MIDLET_SUITE_ID,
					  MIDLET));
    }
}