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