/*
    * Copyright (C) 2008 The Guava Authors
    *
    * 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.common.net;
  
  import static com.google.common.escape.testing.EscaperAsserts.assertEscaping;
  import static com.google.common.escape.testing.EscaperAsserts.assertUnescaped;
  import static com.google.common.escape.testing.EscaperAsserts.assertUnicodeEscaping;
  
  import com.google.common.annotations.GwtCompatible;
  import com.google.common.base.Preconditions;
  import com.google.common.escape.UnicodeEscaper;
  
  import junit.framework.TestCase;
  
  /**
   * Tests for {@link PercentEscaper}.
   *
   * @author David Beaumont
   */
  @GwtCompatible
  public class PercentEscaperTest extends TestCase {
  
    /** Tests that the simple escaper treats 0-9, a-z and A-Z as safe */
    public void testSimpleEscaper() {
      UnicodeEscaper e = new PercentEscaper("", false);
      for (char c = 0; c < 128; c++) {
        if ((c >= '0' && c <= '9') ||
            (c >= 'a' && c <= 'z') ||
            (c >= 'A' && c <= 'Z')) {
          assertUnescaped(e, c);
        } else {
          assertEscaping(e, escapeAscii(c), c);
        }
      }
  
      // Testing mutlibyte escape sequences
      assertEscaping(e, "%00", '\u0000');       // nul
      assertEscaping(e, "%7F", '\u007f');       // del
      assertEscaping(e, "%C2%80", '\u0080');    // xx-00010,x-000000
      assertEscaping(e, "%DF%BF", '\u07ff');    // xx-11111,x-111111
      assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
      assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
      assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');
      assertUnicodeEscaping(e, "%F4%8F%BF%BF", '\uDBFF', '\uDFFF');
  
      // simple string tests
      assertEquals("", e.escape(""));
      assertEquals("safestring", e.escape("safestring"));
      assertEquals("embedded%00null", e.escape("embedded\0null"));
      assertEquals("max%EF%BF%BFchar", e.escape("max\uffffchar"));
    }
  
    /** Tests the various ways that the space character can be handled */
    public void testPlusForSpace() {
      UnicodeEscaper basicEscaper = new PercentEscaper("", false);
      UnicodeEscaper plusForSpaceEscaper = new PercentEscaper("", true);
      UnicodeEscaper spaceEscaper = new PercentEscaper(" ", false);
  
      assertEquals("string%20with%20spaces",
          basicEscaper.escape("string with spaces"));
      assertEquals("string+with+spaces",
          plusForSpaceEscaper.escape("string with spaces"));
      assertEquals("string with spaces",
          spaceEscaper.escape("string with spaces"));
    }
  
    /** Tests that if we add extra 'safe' characters they remain unescaped */
    public void testCustomEscaper() {
      UnicodeEscaper e = new PercentEscaper("+*/-", false);
      for (char c = 0; c < 128; c++) {
        if ((c >= '0' && c <= '9') ||
            (c >= 'a' && c <= 'z') ||
            (c >= 'A' && c <= 'Z') ||
            "+*/-".indexOf(c) >= 0) {
          assertUnescaped(e, c);
        } else {
          assertEscaping(e, escapeAscii(c), c);
        }
      }
    }
  
    /** Tests that if specify '%' as safe the result is an idempotent escaper. */
    public void testCustomEscaper_withpercent() {
      UnicodeEscaper e = new PercentEscaper("%", false);
      assertEquals("foo%7Cbar", e.escape("foo|bar"));
     assertEquals("foo%7Cbar", e.escape("foo%7Cbar"));  // idempotent
   }
 
   /**
    * Test that giving a null 'safeChars' string causes a
    * {@link NullPointerException}.
    */
   public void testBadArguments_null() {
     try {
       new PercentEscaper(null, false);
       fail("Expected null pointer exception for null parameter");
     } catch (NullPointerException expected) {
       // pass
     }
   }
 
   /**
    * Tests that specifying any alphanumeric characters as 'safe' causes an
    * {@link IllegalArgumentException}.
    */
   public void testBadArguments_badchars() {
     String msg = "Alphanumeric characters are always 'safe' " +
         "and should not be explicitly specified";
     try {
       new PercentEscaper("-+#abc.!", false);
       fail(msg);
     } catch (IllegalArgumentException expected) {
       assertEquals(msg, expected.getMessage());
     }
   }
 
   /**
    * Tests that if space is a safe character you cannot also specify
    * 'plusForSpace' (throws {@link IllegalArgumentException}).
    */
   public void testBadArguments_plusforspace() {
     try {
       new PercentEscaper(" ", false);
     } catch (IllegalArgumentException e) {
       fail("Space can be a 'safe' character if plusForSpace is false");
     }
     String msg =
         "plusForSpace cannot be specified when space is a 'safe' character";
     try {
       new PercentEscaper(" ", true);
       fail(msg);
     } catch (IllegalArgumentException expected) {
       assertEquals(msg, expected.getMessage());
     }
   }
 
   /** Helper to manually escape a 7-bit ascii character */
   private String escapeAscii(char c) {
     Preconditions.checkArgument(c < 128);
     String hex = "0123456789ABCDEF";
     return "%" + hex.charAt((c >> 4) & 0xf) + hex.charAt(c & 0xf);
   }
 }