1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package org.apache.harmony.regex.tests.java.util.regex;
18
19import java.io.ObjectStreamClass;
20import java.io.Serializable;
21import java.util.regex.Pattern;
22import java.util.regex.PatternSyntaxException;
23
24import junit.framework.TestCase;
25import org.apache.harmony.testframework.serialization.SerializationTest;
26import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
27
28public class PatternSyntaxExceptionTest extends TestCase {
29  public void testPatternSyntaxException() {
30    // Normal case
31    PatternSyntaxException e = new PatternSyntaxException("Foo", "Bar", 0);
32    assertEquals("Foo", e.getDescription());
33    assertEquals("Bar", e.getPattern());
34    assertEquals(0, e.getIndex());
35
36    String s = e.getMessage();
37    assertTrue(s.contains("Foo"));
38    assertTrue(s.contains("Bar"));
39    assertTrue(s.contains("0"));
40
41    // No description specified
42    e = new PatternSyntaxException(null, "Bar", 0);
43    assertEquals(null, e.getDescription());
44    assertEquals("Bar", e.getPattern());
45    assertEquals(0, e.getIndex());
46
47    s = e.getMessage();
48    assertFalse(s.contains("Foo"));
49    assertTrue(s.contains("Bar"));
50    assertTrue(s.contains("0"));
51
52    // No pattern specified
53    e = new PatternSyntaxException("Foo", null, 0);
54    assertEquals("Foo", e.getDescription());
55    assertEquals(null, e.getPattern());
56    assertEquals(0, e.getIndex());
57
58    s = e.getMessage();
59    assertTrue(s.contains("Foo"));
60    assertFalse(s.contains("Bar"));
61    assertTrue(s.contains("0"));
62
63    // Neither description nor pattern specified
64    e = new PatternSyntaxException(null, null, 0);
65    assertEquals(null, e.getDescription());
66    assertEquals(null, e.getPattern());
67    assertEquals(0, e.getIndex());
68
69    s = e.getMessage();
70    assertFalse(s.contains("Foo"));
71    assertFalse(s.contains("Bar"));
72    assertTrue(s.contains("0"));
73
74    // No index specified
75    e = new PatternSyntaxException("Foo", "Bar", -1);
76    assertEquals(-1, e.getIndex());
77
78    s = e.getMessage();
79    assertFalse(s.contains("^"));
80
81    // No pattern, but index specified. NOTE: This is an "unusual" case since
82    // it make no sense to provide an index and not a pattern.
83    e = new PatternSyntaxException("Foo", null, 0);
84    assertEquals(0, e.getIndex());
85
86    s = e.getMessage();
87    assertTrue(s.contains("^"));
88    assertTrue(s.contains("null"));
89  }
90
91  public void testCase() {
92    String regex = "(";
93    try {
94      Pattern.compile(regex);
95      fail("PatternSyntaxException expected");
96    } catch (PatternSyntaxException e) {
97      assertEquals(1, e.getIndex());
98      assertEquals(regex, e.getPattern());
99    }
100  }
101
102  public void testCase2() {
103    String regex = "[4-";
104    try {
105      Pattern.compile(regex);
106      fail("PatternSyntaxException expected");
107    } catch (PatternSyntaxException e) {
108      assertEquals(3, e.getIndex());
109      assertEquals(regex, e.getPattern());
110    }
111  }
112
113  // Regression test for HARMONY-3787
114  public void test_objectStreamField() {
115    ObjectStreamClass objectStreamClass = ObjectStreamClass.lookup(PatternSyntaxException.class);
116    assertNotNull(objectStreamClass.getField("desc"));
117  }
118
119  public void testSerializationCompatibility() throws Exception {
120    PatternSyntaxException object = new PatternSyntaxException("TESTDESC", "TESTREGEX", 3);
121    SerializationTest.verifyGolden(this, object, PATTERNSYNTAXEXCEPTION_COMPARATOR);
122  }
123
124  public void testSerializationSelf() throws Exception {
125    PatternSyntaxException object = new PatternSyntaxException("TESTDESC", "TESTREGEX", 3);
126    SerializationTest.verifySelf(object, PATTERNSYNTAXEXCEPTION_COMPARATOR);
127  }
128
129  private static final SerializableAssert PATTERNSYNTAXEXCEPTION_COMPARATOR = new SerializableAssert() {
130    public void assertDeserialized(Serializable initial, Serializable deserialized) {
131
132      // do common checks for all throwable objects
133      SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial, deserialized);
134
135      PatternSyntaxException initPatternSyntaxException = (PatternSyntaxException) initial;
136      PatternSyntaxException dserPatternSyntaxException = (PatternSyntaxException) deserialized;
137
138      // verify fields
139      assertEquals(initPatternSyntaxException.getDescription(),
140                   dserPatternSyntaxException.getDescription());
141      assertEquals(initPatternSyntaxException.getPattern(),
142                   dserPatternSyntaxException.getPattern());
143      assertEquals(initPatternSyntaxException.getIndex(),
144                   dserPatternSyntaxException.getIndex());
145    }
146  };
147}
148