/**
 * Copyright 2009 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 org.waveprotocol.wave.model.id;


import junit.framework.TestCase;

import java.util.Arrays;

/**
 * @author zdwang@google.com (David Wang)
 */

public class SimplePrefixEscaperTest extends TestCase {

  private final SimplePrefixEscaper escaper = SimplePrefixEscaper.DEFAULT_ESCAPER;

  /**
   * Test simple escaping and the unescaping.
   */
  public void testSimpleEscapingUnescaping() {
    utilTestEscapeUnescape("abc", "abc");

    // Middle of the string.
    utilTestEscapeUnescape("a~+~!~~bc", "a+!~bc");

    // Beginning and end of the string.
    utilTestEscapeUnescape("~!abc~+", "!abc+");

    // Empty
    utilTestEscapeUnescape("", "");

    // Single
    utilTestEscapeUnescape("~+", "+");
  }

  private void utilTestEscapeUnescape(String escaped, String unescaped) {
    assertEquals(escaped, escaper.escape(unescaped));
    assertEquals(unescaped, escaper.unescape(escaped));
  }

  /**
   * Test the unescaping of various illegally escaped strings.
   */
  public void testUnescapingFail() {
    // Escaping nothing
    utilTestUnescapeFail("~");

    // There are unescaped chars
    utilTestUnescapeFail("~~~");
    utilTestUnescapeFail("~~!");
    utilTestUnescapeFail("~!~");
    utilTestUnescapeFail("!~~");

    // Escaping something that does not require escaping
    utilTestUnescapeFail("~a");
  }

  private void utilTestUnescapeFail(String escaped) {
    try {
      escaper.unescape(escaped);
      fail("Not supposed to allow unescaping of malformed string.");
    } catch (IllegalArgumentException ex) {
      // Expected
    }
  }

  /**
   * Test simple join and split.
   */
  public void testJoinSplit() {
    utilTestJoinSplit("a!b", '!', "a", "b");

    // Nothing to join
    utilTestJoinSplit("", '!', "");
    utilTestJoinSplit("!", '!', "", "");
    utilTestJoinSplit("ab", '!', "ab");

    // Needs escaping
    utilTestJoinSplit("~~!~!", '!', "~", "!");
    utilTestJoinSplit("~~!~~", '!', "~", "~");
    utilTestJoinSplit("~!!~!", '!', "!", "!");
  }

  private void utilTestJoinSplit(String joinedString, char separator, String... tokens) {
    assertEquals(joinedString, escaper.join(separator, tokens));
    assertEquals(Arrays.asList(tokens), Arrays.asList(escaper.split(separator, joinedString)));
  }

  public void testJoinFail() {
    // Empty tokens
    utilTestJoinFail('!');

    // Using prefix for join
    utilTestJoinFail('~', "a", "b");

    // Not using escape chars
    utilTestJoinFail('-', "a", "b");
  }

  private void utilTestJoinFail(char separator, String... tokens) {
    try {
      escaper.join(separator, tokens);
      fail("Not supposed to allow illegal joinning.");
    } catch (IllegalArgumentException ex) {
      // Expected
    }
  }

  /**
   * Test strings that can't be split.
   */
  public void testSplitFail() {
    // Cannot split using prefix
    utilTestSplitFail('~', "a~b");

    // Invalid strings
    utilTestSplitFail('!', "~aa!b");
    utilTestSplitFail('!', "~");
    utilTestSplitFail('!', "ab~");
    utilTestSplitFail('!', "ab!+");
  }

  private void utilTestSplitFail(char separator, String toSplit) {
    try {
      escaper.split(separator, toSplit);
      fail("Not supposed to be able to split invalid strings.");
    } catch (IllegalArgumentException ex) {
      // Expected
    }
  }

  public void testEscapedId() {
    utilTestEscapedId("google.com", "abc");
    utilTestEscapedId("google.com", "+c");
    utilTestEscapedId("google.com", "~~w~~a+v~!e~+~~");

    // bad domain
    utilTestEscapedIdFail("google.!com", "abc");

    // bad id
    utilTestEscapedIdFail("google.com", "ab+~c");
    utilTestEscapedIdFail("google.com", "ab!+!c");
    utilTestEscapedIdFail("google.com", "ab!c");
    utilTestEscapedIdFail("google.com", "!c");
    utilTestEscapedIdFail("google.com", "~~w~a+v~!e~+~~");
  }

  private void utilTestEscapedId(String domain, String id) {
    try {
      WaveId.ofLegacy(domain, id);
      WaveletId.ofLegacy(domain, id);
    } catch (IllegalArgumentException ex) {
      fail("Not supposed to throw exception: " + ex.getMessage());
    }
  }

  private void utilTestEscapedIdFail(String domain, String id) {
    try {
      WaveId.ofLegacy(domain, id);
      fail("Not supposed to be able to create invalid WaveId");
    } catch (IllegalArgumentException ex) {
      // Expected
    }

    try {
      WaveletId.ofLegacy(domain, id);
      fail("Not supposed to be able to create invalid WaveletId");
    } catch (IllegalArgumentException ex) {
      // Expected
    }
  }
}