/*
 * Copyright 2007 Google Inc.
 * 
 * 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 com.google.gwt.user.client;

import com.google.gwt.core.client.Duration;
import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.GWT.UncaughtExceptionHandler;
import com.google.gwt.junit.client.GWTTestCase;

/**
 * Test cases for {@link CommandExecutor}.
 */
public class CommandExecutorTest extends GWTTestCase {

  private static class NonRestartingCommandExecutor extends CommandExecutor {
    protected void maybeStartExecutionTimer() {
      // keeps the executing timer for interfering with the test
    }
  }

  private static class TestCommand implements Command {
    private boolean executed;

    public boolean didExecute() {
      return executed;
    }

    public void execute() {
      executed = true;
    }
  }

  private static class TestIncrementalCommand implements IncrementalCommand {
    private boolean done = false;
    private int executeCount;

    public boolean execute() {
      ++executeCount;

      return !isDone();
    }

    public int getExecuteCount() {
      return executeCount;
    }

    public boolean isDone() {
      return done;
    }

    public void setDone(boolean done) {
      this.done = done;
    }
  }

  /**
   * A sufficiently large delay to let the SSW triggers.
   */
  private static final int TEST_FINISH_DELAY_MILLIS = 40000;

  public String getModuleName() {
    return "com.google.gwt.user.User";
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks that we can recover after a cancellation
   */
  public void testDoExecuteCommands_CancellationRecovery() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    final Command c1 = new Command() {
      public void execute() {
      }
    };

    ce.setExecuting(true);
    ce.submit(c1);
    ce.setLast(0);

    final UncaughtExceptionHandler originalUEH = GWT.getUncaughtExceptionHandler();

    UncaughtExceptionHandler ueh1 = new UncaughtExceptionHandler() {
      public void onUncaughtException(Throwable e) {
        if (!(e instanceof CommandCanceledException)) {
          originalUEH.onUncaughtException(e);
          return;
        }

        CommandCanceledException cce = (CommandCanceledException) e;
        if (cce.getCommand() != c1) {
          fail("CommandCanceledException did not contain the correct failed command");
        }

        // Submit some more work and do another dispatch
        ce.submit(new IncrementalCommand() {
          public boolean execute() {
            return false;
          }
        });

        delayTestFinish(TEST_FINISH_DELAY_MILLIS);
        ce.submit(new Command() {
          public void execute() {
            finishTest();
          }
        });

        ce.doExecuteCommands(Duration.currentTimeMillis());
      }
    };

    GWT.setUncaughtExceptionHandler(ueh1);
    ce.doCommandCanceled();
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks Command cancellation detection
   */
  public void testDoExecuteCommands_CommandCancellation() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    final Command c1 = new Command() {
      public void execute() {
      }
    };

    // Setup the cancellation state
    ce.setExecuting(true);
    ce.submit(c1);
    ce.setLast(0);

    final UncaughtExceptionHandler originalUEH = GWT.getUncaughtExceptionHandler();

    UncaughtExceptionHandler ueh1 = new UncaughtExceptionHandler() {
      public void onUncaughtException(Throwable e) {
        if (!(e instanceof CommandCanceledException)) {
          originalUEH.onUncaughtException(e);
          return;
        }

        CommandCanceledException cce = (CommandCanceledException) e;
        if (cce.getCommand() != c1) {
          fail("CommandCanceledException did not contain the correct failed command");
        }
      }
    };

    GWT.setUncaughtExceptionHandler(ueh1);
    ce.doCommandCanceled();
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks that calling {@link CommandExecutor#doExecuteCommands(double)} with no
   * items in the queue is safe
   */
  public void testDoExecuteCommands_emptyQueue() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    ce.doExecuteCommands(Duration.currentTimeMillis());
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks IncrementalCommand cancellation detection
   */
  public void testDoExecuteCommands_IncrementalCommandCancellation() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    final IncrementalCommand ic = new IncrementalCommand() {
      public boolean execute() {
        return false;
      }
    };

    // setup the cancellation state
    ce.setExecuting(true);
    ce.submit(ic);
    ce.setLast(0);

    final UncaughtExceptionHandler originalUEH = GWT.getUncaughtExceptionHandler();

    UncaughtExceptionHandler ueh1 = new UncaughtExceptionHandler() {
      public void onUncaughtException(Throwable e) {
        if (!(e instanceof IncrementalCommandCanceledException)) {
          originalUEH.onUncaughtException(e);
          return;
        }

        IncrementalCommandCanceledException icce = (IncrementalCommandCanceledException) e;
        if (icce.getCommand() != ic) {
          fail("IncrementalCommandCanceledException did not contain the correct failed command");
        }
      }
    };

    GWT.setUncaughtExceptionHandler(ueh1);
    ce.doCommandCanceled();
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks that an incremental command executes and is removed from the queue
   * when it is done
   */
  public void testDoExecuteCommands_IncrementalCommands() {
    TestIncrementalCommand tic = new TestIncrementalCommand();
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    tic.setDone(true);
    ce.submit(tic);
    ce.doExecuteCommands(Duration.currentTimeMillis());
    assertTrue(tic.getExecuteCount() > 0);
    assertTrue(ce.getPendingCommands().isEmpty());
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks that null does in fact cause a pause.
   */
  public void testDoExecuteCommands_pause() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    TestCommand tc1 = new TestCommand();
    TestCommand tc2 = new TestCommand();

    ce.submit(tc1);
    ce.submit((Command) null);
    ce.submit(tc2);

    ce.doExecuteCommands(Duration.currentTimeMillis());

    assertTrue(tc1.didExecute() && !tc2.didExecute());
    assertEquals(1, ce.getPendingCommands().size());
    assertTrue(ce.getPendingCommands().contains(tc2));
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#doExecuteCommands(int)}.
   * 
   * Checks that after one pass dispatch pass, we still have the incremental
   * command in the queue
   */
  public void testDoExecuteCommands_timeSliceUsage() {
    final CommandExecutor ce = new NonRestartingCommandExecutor();

    Command tc = new TestCommand();
    ce.submit(tc);

    TestIncrementalCommand tic = new TestIncrementalCommand();
    ce.submit(tic);
    ce.doExecuteCommands(Duration.currentTimeMillis());

    assertEquals(1, ce.getPendingCommands().size());
    assertTrue(ce.getPendingCommands().contains(tic));
    assertTrue(tic.getExecuteCount() > 0);
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#submit(com.google.gwt.user.client.Command)}.
   * 
   * <p/> Cases:
   * <ul>
   * <li>Submit <code>null</code></li>
   * <li>Submit {@link Command} and make sure that it fires</li>
   * </ul>
   */
  public void testSubmitCommand() {
    CommandExecutor ce = new CommandExecutor();
    ce.submit((Command) null);

    delayTestFinish(TEST_FINISH_DELAY_MILLIS);

    ce.submit(new Command() {
      public void execute() {
        finishTest();
      }
    });
  }

  /**
   * Test method for
   * {@link com.google.gwt.user.client.CommandExecutor#submit(com.google.gwt.user.client.IncrementalCommand)}.
   * 
   * <p/> Cases:
   * <ul>
   * <li>Submit <code>null</code></li>
   * <li>Submit {@link IncrementalCommand} and make sure that it fires as many
   * times as we want it to</li>
   * </ul>
   */
  public void testSubmitIncrementalCommand() {
    CommandExecutor ce = new CommandExecutor();
    ce.submit((Command) null);

    delayTestFinish(TEST_FINISH_DELAY_MILLIS);

    ce.submit(new IncrementalCommand() {
      private int executionCount = 0;

      public boolean execute() {
        if (++executionCount > 10) {
          fail("IncrementalCommand was fired more than 10 times");
        }

        if (executionCount == 10) {
          finishTest();
        }

        return executionCount < 10;
      }
    });
  }
}