Example #1
0
  //    @Test
  public void testChain() {
    System.out.println("chain");
    final Task instance =
        new Task(Task.FASTLANE_PRIORITY, "1") {
          protected Object exec(Object in) {
            return (String) in + "2";
          }
        };
    final Task instance2 =
        new Task(Task.FASTLANE_PRIORITY, "bad") {
          protected Object exec(Object in) {
            return in + "3";
          }
        };
    final Task instance3 =
        new Task(Task.FASTLANE_PRIORITY, "ugly") {
          protected Object exec(Object in) {
            return in + "4";
          }
        };
    final Task instanceA =
        new Task(Task.FASTLANE_PRIORITY, "A") {
          @Override
          protected Object exec(Object in) {
            return (String) in + "B";
          }
        };
    final Task instance5 =
        new Task(Task.FASTLANE_PRIORITY, "5") {
          @Override
          protected Object exec(Object in) {
            return (String) in + "6";
          }
        };
    final Task instance6 =
        new Task(Task.FASTLANE_PRIORITY, "BAD") {
          @Override
          protected Object exec(Object in) {
            return in + "7";
          }
        };
    try {
      instance.chain(instance2).chain(instance3);
      instance.fork().join(200);
      assertEquals("12", (String) instance.get());
      assertEquals("123", (String) instance2.get());
      assertEquals("1234", (String) instance3.get());

      instanceA.chain(instance5);
      instanceA.chain(null);
      instanceA.chain(instance6);
      instanceA.fork();
      assertEquals("AB", (String) instanceA.get());
      assertEquals("AB67", (String) instance6.get());
    } catch (Exception ex) {
      ex.printStackTrace();
      fail("Can not chain: " + ex);
    }
  }
Example #2
0
  public void taskChainDelayTest() {
    final long t = System.currentTimeMillis();

    Task sleeper3sec =
        new Task(Task.HIGH_PRIORITY) {
          protected Object exec(Object in) {
            try {
              L.i("sleeper3", "start sleep");
              Thread.sleep(3000);
              L.i("sleeper3", "end sleep");
            } catch (Exception e) {
              L.e("Problem with sleeper4", "", e);
            }

            return in;
          }
        };
    Task sleeper3chain =
        new Task(Task.FASTLANE_PRIORITY) {
          protected Object exec(Object in) {
            L.i("getter3sec", "completed");
            return new Long(System.currentTimeMillis() - t);
          }
        };
    Task sleeper4sec =
        new Task(Task.HIGH_PRIORITY) {
          protected Object exec(Object in) {
            try {
              L.i("sleeper4", "start sleep");
              Thread.sleep(4000);
              L.i("sleeper4", "end sleep");
            } catch (Exception e) {
              L.e("Problem with sleeper3", "", e);
            }

            return in;
          }
        };
    Task sleeper4chain =
        new Task(Task.HIGH_PRIORITY) {
          protected Object exec(Object in) {
            L.i("getter10sec", "completed");
            in = new Long(System.currentTimeMillis() - t);

            return in;
          }
        };

    sleeper3sec.chain(sleeper3chain);
    sleeper4sec.chain(sleeper4chain);
    sleeper4sec.fork();
    sleeper3sec.fork();
    Task[] sleepers = {sleeper4sec, sleeper3sec};
    try {
      Task.joinAll(sleepers);
      assertTrue("joinAll() waiting >4sec", System.currentTimeMillis() - t >= 4000);
      Object long4 = sleeper4chain.get();
      Object long3 = sleeper3chain.get();
      assertTrue("sleeper4chain should be non-null", long4 != null);
      assertTrue("sleeper3chain should be non-null", long3 != null);
      assertEquals("sleeper4 should return Long", Long.class, long4.getClass());
      assertEquals("sleeper3 should return Long", Long.class, long3.getClass());
      final long runtime4 = ((Long) long4).longValue();
      final long runtime3 = ((Long) long3).longValue();
      assertTrue(
          "4sec chain delay task "
              + runtime4
              + " should be slower than 3sec "
              + runtime3
              + " delay task",
          runtime3 < runtime4);
      assertTrue(
          "4sec chain delay task "
              + runtime4
              + " should be nearly 1 sec after 3sec "
              + runtime3
              + " delay task",
          Math.abs(runtime4 - runtime3 - 1000) < 100);
    } catch (Exception e) {
      fail("Problem running taskChainDelayTest: " + e);
    }
  }
Example #3
0
  //    @Test
  public void testCancelSelf() {
    System.out.println("cancelSelf");
    final Task task1a =
        new Task(Task.FASTLANE_PRIORITY, "1") {
          @Override
          protected Object exec(Object in) {
            return (String) in + "2";
          }
        };
    final Task task1aChain =
        new Task(Task.UI_PRIORITY) {
          @Override
          protected Object exec(Object in) {
            try {
              // TEST FOR LOGIC ERROR- you can not set() after background execution completes
              set("UI");
              fail("set() after run should have been stopped");
            } catch (Exception e) {
            }
            return in;
          }
        };
    final Task task1b =
        new Task(Task.FASTLANE_PRIORITY, "3") {
          protected Object exec(Object in) {
            return (String) in + "4";
          }

          public void run(Object result) {
            // TEST FOR LOGIC ERROR- you can not cancel() after background execution completes
            try {
              cancel("testing");
              fail("cancel() after run should have been stopped");
            } catch (Exception e) {
            }
          }
        };
    final Task task2 =
        new Task(Task.FASTLANE_PRIORITY, "5") {
          @Override
          protected Object exec(Object in) {
            cancel("testing");

            return in + "6";
          }
        };
    final Task task3 =
        new Task(Task.FASTLANE_PRIORITY, "B") {
          protected Object exec(Object in) {
            cancel("testing");

            return in + "C";
          }
        };
    final Task task4 =
        new Task(Task.FASTLANE_PRIORITY, "D") {
          protected Object exec(Object in) {
            cancel("testing");

            return in + "E";
          }
        };

    try {
      task1a.chain(task1aChain);
      task1a.fork();
      Thread.sleep(300);
      assertEquals("task1a was FINISHED", Task.FINISHED, task1a.getStatus());
      assertEquals("task1a result was 12", "12", task1a.get());

      task1b.fork().join();
      assertEquals("task1b was not EXEC_FINISHED", Task.FINISHED, task1b.getStatus());

      task2.fork().join();
      assertEquals(
          "task2 should not have been CANCELED- you can not cancel() yourself",
          Task.FINISHED,
          task2.getStatus());

      task3.fork().join();
      assertNotEquals("task4a should not have been CANCELED", Task.CANCELED, task3.getStatus());

      try {
        task4.fork().join();
        fail("Task 4b- join() should throw ClassCastException if Task (not UITask)");
      } catch (ClassCastException e) {
        // Normal execution path
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      fail("Can not testCancelSelf: " + ex);
    }
  }